mutations 0.5.11 → 0.5.12

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+0.5.12
+-----------
+
+- Added a duck filter: ```duck :lengthy, methods: :length``` to ensure all values respond_to? :length [#14]
+- Added a file filter: ```file :data``` to ensure the data is a File-like object [#15]
+- Allow raw_inputs to be used as method inside of execute to access the original data passed in. (@tomtaylor)
+- integer filter now allows the ```in``` option. Eg: ```integer :http_code, in: (200, 404, 401)```   (/via @tomtaylor)
+- Added a changelog. [#10]
+
+0.5.11
+-----------
+
+- Float filter (@aq1018)
+- Clean up public API + code (@blambeau)
+- Model filters should lazily resolve their classes so that mocks can be used (@edwinv)
+- Filtered inputs should be included in the Outcome
+- Fix typos (@frodsan)
+ 
+0.5.10 and earlier
+-----------
+
+- Initial versions

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mutations (0.5.11)
+    mutations (0.5.12)
       activesupport
 
 GEM

data/lib/mutations.rb

@@ -10,6 +10,8 @@ require 'mutations/string_filter'
 require 'mutations/integer_filter'
 require 'mutations/float_filter'
 require 'mutations/boolean_filter'
+require 'mutations/duck_filter'
+require 'mutations/file_filter'
 require 'mutations/model_filter'
 require 'mutations/array_filter'
 require 'mutations/hash_filter'

data/lib/mutations/array_filter.rb

@@ -34,6 +34,14 @@ module Mutations
     def boolean(options = {})
       @element_filter = BooleanFilter.new(options)
     end
+    
+    def duck(options = {})
+      @element_filter = DuckFilter.new(options)
+    end
+    
+    def file(options = {})
+      @element_filter = FileFilter.new(options)
+    end
 
     def hash(options = {}, &block)
       @element_filter = HashFilter.new(options, &block)
@@ -87,7 +95,6 @@ module Mutations
 
     # Returns [filtered, errors]
     def filter_element(data)
-
       if @element_filter
         data, el_errors = @element_filter.filter(data)
         return [data, el_errors] if el_errors

data/lib/mutations/command.rb

@@ -6,15 +6,15 @@ module Mutations
         keys = self.input_filters.send("#{meth}_keys")
         keys.each do |key|
           define_method(key) do
-            @filtered_input[key]
+            @inputs[key]
           end
 
           define_method("#{key}_present?") do
-            @filtered_input.has_key?(key)
+            @inputs.has_key?(key)
           end
 
           define_method("#{key}=") do |v|
-            @filtered_input[key] = v
+            @inputs[key] = v
           end
         end
       end
@@ -55,11 +55,12 @@ module Mutations
 
     # Instance methods
     def initialize(*args)
-      @original_hash = args.each_with_object({}.with_indifferent_access) do |arg, h|
+      @raw_inputs = args.each_with_object({}.with_indifferent_access) do |arg, h|
         raise ArgumentError.new("All arguments must be hashes") unless arg.is_a?(Hash)
         h.merge!(arg)
       end
-      @filtered_input, @errors = self.input_filters.filter(@original_hash)
+      
+      @inputs, @errors = self.input_filters.filter(@raw_inputs)
     end
 
     def input_filters
@@ -88,13 +89,14 @@ module Mutations
       validation_outcome
     end
 
-    # Runs input thru the filter and sets @filtered_input and @errors
     def validation_outcome(result = nil)
-      Outcome.new(!has_errors?, has_errors? ? nil : result, @errors, @filtered_input)
+      Outcome.new(!has_errors?, has_errors? ? nil : result, @errors, @inputs)
     end
 
   protected
 
+    attr_reader :inputs, :raw_inputs
+
     def execute
       # Meant to be overridden
     end
@@ -121,8 +123,5 @@ module Mutations
       @errors.merge!(hash)
     end
 
-    def inputs
-      @filtered_input
-    end
   end
-end
+end

data/lib/mutations/duck_filter.rb

@@ -0,0 +1,25 @@
+module Mutations
+  class DuckFilter < InputFilter
+    @default_options = {
+      nils: false,       # true allows an explicit nil to be valid. Overrides any other options
+      methods: nil       # The object needs to respond to each of the symbols in this array.
+    }
+
+    def filter(data)
+
+      # Handle nil case
+      if data.nil?
+        return [nil, nil] if options[:nils]
+        return [nil, :nils]
+      end
+
+      # Ensure the data responds to each of the methods
+      Array(options[:methods]).each do |method|
+        return [data, :duck] unless data.respond_to?(method)
+      end
+
+      # We win, it's valid!
+      [data, nil]
+    end
+  end
+end

data/lib/mutations/file_filter.rb

@@ -0,0 +1,32 @@
+module Mutations
+  class FileFilter < InputFilter
+    @default_options = {
+      nils: false,       # true allows an explicit nil to be valid. Overrides any other options
+      upload: false,     # if true, also checks the file is has original_filename and content_type methods.
+      size: nil          # An integer value like 1_000_000 limits the size of the file to 1M bytes
+    }
+
+    def filter(data)
+
+      # Handle nil case
+      if data.nil?
+        return [nil, nil] if options[:nils]
+        return [nil, :nils]
+      end
+
+      # Ensure the data responds to each of the methods
+      methods = [:read, :size]
+      methods.concat([:original_filename, :content_type]) if options[:upload]
+      methods.each do |method|
+        return [data, :file] unless data.respond_to?(method)
+      end
+      
+      if options[:size].is_a?(Fixnum)
+        return [data, :size] if data.size > options[:size] 
+      end
+
+      # We win, it's valid!
+      [data, nil]
+    end
+  end
+end

data/lib/mutations/hash_filter.rb

@@ -64,12 +64,19 @@ module Mutations
     def boolean(name, options = {})
       @current_inputs[name.to_sym] = BooleanFilter.new(options)
     end
+    
+    def duck(name, options = {})
+      @current_inputs[name.to_sym] = DuckFilter.new(options)
+    end
+    
+    def file(name, options = {})
+      @current_inputs[name.to_sym] = FileFilter.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)

data/lib/mutations/integer_filter.rb

@@ -3,7 +3,8 @@ module Mutations
     @default_options = {
       nils: false,       # true allows an explicit nil to be valid. Overrides any other options
       min: nil,          # lowest value, inclusive
-      max: nil           # highest value, inclusive
+      max: nil,          # highest value, inclusive
+      in: nil            # Can be an array like %w(3 4 5)
     }
 
     def filter(data)
@@ -26,8 +27,11 @@ module Mutations
       return [data, :min] if options[:min] && data < options[:min]
       return [data, :max] if options[:max] && data > options[:max]
 
+      # Ensure it matches `in`
+      return [data, :in] if options[:in] && !options[:in].include?(data)
+
       # We win, it's valid!
       [data, nil]
     end
   end
-end
+end

data/lib/mutations/version.rb

@@ -1,3 +1,3 @@
 module Mutations
-  VERSION = "0.5.11"
+  VERSION = "0.5.12"
 end

data/spec/array_filter_spec.rb

@@ -1,4 +1,5 @@
 require_relative 'spec_helper'
+require 'stringio'
 
 describe "Mutations::ArrayFilter" do
 
@@ -91,6 +92,23 @@ describe "Mutations::ArrayFilter" do
     assert_equal [5.0,6.0,1.0,"bob"], filtered
     assert_equal [nil, nil, :min, :float], errors.symbolic
   end
+  
+  it "lets you pass ducks in arrays" do
+    f = Mutations::ArrayFilter.new(:arr) { duck(methods: :length) }
+
+    filtered, errors = f.filter(["hi", [1], true])
+    assert_equal ["hi", [1], true], filtered
+    assert_equal [nil, nil, :duck], errors.symbolic
+  end
+  
+  it "lets you pass files in arrays" do
+    sio = StringIO.new("bob")
+    f = Mutations::ArrayFilter.new(:arr) { file }
+
+    filtered, errors = f.filter([sio, "bob"])
+    assert_equal [sio, "bob"], filtered
+    assert_equal [nil, :file], errors.symbolic
+  end
 
   it "lets you pass booleans in arrays" do
     f = Mutations::ArrayFilter.new(:arr) { boolean }

data/spec/command_spec.rb

@@ -201,4 +201,22 @@ describe "Command" do
     end
   end
 
+  describe "RawInputsCommand" do
+    class RawInputsCommand < Mutations::Command
+
+      required do
+        string :name
+      end
+
+      def execute
+        return raw_inputs
+      end
+    end
+
+    it "should return the raw input data" do
+      input = { "name" => "Hello World", "other" => "Foo Bar Baz" }
+      assert_equal input, RawInputsCommand.run!(input)
+    end
+  end
+
 end

data/spec/duck_filter_spec.rb

@@ -0,0 +1,49 @@
+require_relative 'spec_helper'
+
+describe "Mutations::DuckFilter" do
+
+  it "allows objects that respond to a single specified method" do
+    f = Mutations::DuckFilter.new(methods: [:length])
+    filtered, errors = f.filter("test")
+    assert_equal "test", filtered
+    assert_equal nil, errors
+
+    filtered, errors = f.filter([1, 2])
+    assert_equal [1, 2], filtered
+    assert_equal nil, errors
+  end
+
+  it "doesn't allow objects that respond to a single specified method" do
+    f = Mutations::DuckFilter.new(methods: [:length])
+    filtered, errors = f.filter(true)
+    assert_equal true, filtered
+    assert_equal :duck, errors
+
+    filtered, errors = f.filter(12)
+    assert_equal 12, filtered
+    assert_equal :duck, errors
+  end
+
+  it "considers nil to be invalid" do
+    f = Mutations::DuckFilter.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::DuckFilter.new(nils: true)
+    filtered, errors = f.filter(nil)
+    assert_equal nil, filtered
+    assert_equal nil, errors
+  end
+
+  it "Allows anything if no methods are specified" do
+    f = Mutations::DuckFilter.new
+    [true, "hi", 1, [1, 2, 3]].each do |v|
+      filtered, errors = f.filter(v)
+      assert_equal v, filtered
+      assert_equal nil, errors
+    end
+  end
+end

data/spec/file_filter_spec.rb

@@ -0,0 +1,91 @@
+require_relative 'spec_helper'
+require 'stringio'
+require 'tempfile'
+
+describe "Mutations::FileFilter" do
+  
+  class UploadedStringIO < StringIO
+    attr_accessor :content_type, :original_filename
+  end
+
+  it "allows files - file class" do
+    file = File.new("README.md")
+    f = Mutations::FileFilter.new
+    filtered, errors = f.filter(file)
+    assert_equal file, filtered
+    assert_equal nil, errors
+  end
+  
+  it "allows files - stringio class" do
+    file = StringIO.new("bob")
+    f = Mutations::FileFilter.new
+    filtered, errors = f.filter(file)
+    assert_equal file, filtered
+    assert_equal nil, errors
+  end
+  
+  it "allows files - tempfile" do
+    file = Tempfile.new("bob")
+    f = Mutations::FileFilter.new
+    filtered, errors = f.filter(file)
+    assert_equal file, filtered
+    assert_equal nil, errors
+  end
+
+  it "doesn't allow non-files" do
+    f = Mutations::FileFilter.new
+    filtered, errors = f.filter("string")
+    assert_equal "string", filtered
+    assert_equal :file, errors
+  
+    filtered, errors = f.filter(12)
+    assert_equal 12, filtered
+    assert_equal :file, errors
+  end
+
+  it "considers nil to be invalid" do
+    f = Mutations::FileFilter.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::FileFilter.new(nils: true)
+    filtered, errors = f.filter(nil)
+    assert_equal nil, filtered
+    assert_equal nil, errors
+  end
+
+  it "should allow small files" do
+    file = StringIO.new("bob")
+    f = Mutations::FileFilter.new(size: 4)
+    filtered, errors = f.filter(file)
+    assert_equal file, filtered
+    assert_equal nil, errors
+  end
+  
+  it "shouldn't allow big files" do
+    file = StringIO.new("bob")
+    f = Mutations::FileFilter.new(size: 2)
+    filtered, errors = f.filter(file)
+    assert_equal file, filtered
+    assert_equal :size, errors
+  end
+  
+  it "should require extra methods if uploaded file: accept" do
+    file = UploadedStringIO.new("bob")
+    f = Mutations::FileFilter.new(upload: true)
+    filtered, errors = f.filter(file)
+    assert_equal file, filtered
+    assert_equal nil, errors
+  end
+  
+  it "should require extra methods if uploaded file: deny" do
+    file = StringIO.new("bob")
+    f = Mutations::FileFilter.new(upload: true)
+    filtered, errors = f.filter(file)
+    assert_equal file, filtered
+    assert_equal :file, errors
+  end
+end

data/spec/hash_filter_spec.rb

@@ -1,4 +1,5 @@
 require_relative 'spec_helper'
+require 'stringio'
 
 describe "Mutations::HashFilter" do
 
@@ -28,7 +29,7 @@ describe "Mutations::HashFilter" do
     assert_equal nil, errors
   end
 
-  it "allow floats in hashes" do
+  it "allows floats in hashes" do
     hf = Mutations::HashFilter.new do
       float :foo
     end
@@ -36,6 +37,25 @@ describe "Mutations::HashFilter" do
     assert_equal ({"foo" => 3.14}), filtered
     assert_equal nil, errors
   end
+  
+  it "allows ducks in hashes" do
+    hf = Mutations::HashFilter.new do
+      duck :foo, methods: [:length]
+    end
+    filtered, errors = hf.filter(foo: "123")
+    assert_equal ({"foo" => "123"}), filtered
+    assert_equal nil, errors
+  end
+  
+  it "allows files in hashes" do
+    sio = StringIO.new("bob")
+    hf = Mutations::HashFilter.new do
+      file :foo
+    end
+    filtered, errors = hf.filter(foo: sio)
+    assert_equal ({"foo" => sio}), filtered
+    assert_equal nil, errors
+  end
 
   it "doesn't allow wildcards in hashes" do
     hf = Mutations::HashFilter.new do

data/spec/inheritance_spec.rb

@@ -10,7 +10,7 @@ describe 'Mutations - inheritance' do
     end
 
     def execute
-      @filtered_input
+      inputs
     end
   end
 

data/spec/integer_filter_spec.rb

@@ -73,4 +73,18 @@ describe "Mutations::IntegerFilter" do
     assert_equal nil, errors
   end
 
-end
+  it "considers not matching numbers to be invalid" do
+    f = Mutations::IntegerFilter.new(in: [3, 4, 5])
+    filtered, errors = f.filter(6)
+    assert_equal 6, filtered
+    assert_equal :in, errors
+  end
+
+  it "considers matching numbers to be valid" do
+    f = Mutations::IntegerFilter.new(in: [3, 4, 5])
+    filtered, errors = f.filter(3)
+    assert_equal 3, filtered
+    assert_nil errors
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutations
 version: !ruby/object:Gem::Version
-  version: 0.5.11
+  version: 0.5.12
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-02 00:00:00.000000000 Z
+date: 2013-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -68,6 +68,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - MIT-LICENSE
@@ -78,8 +79,10 @@ files:
 - lib/mutations/array_filter.rb
 - lib/mutations/boolean_filter.rb
 - lib/mutations/command.rb
+- lib/mutations/duck_filter.rb
 - lib/mutations/errors.rb
 - lib/mutations/exception.rb
+- lib/mutations/file_filter.rb
 - lib/mutations/float_filter.rb
 - lib/mutations/hash_filter.rb
 - lib/mutations/input_filter.rb
@@ -93,7 +96,9 @@ files:
 - spec/boolean_filter_spec.rb
 - spec/command_spec.rb
 - spec/default_spec.rb
+- spec/duck_filter_spec.rb
 - spec/errors_spec.rb
+- spec/file_filter_spec.rb
 - spec/float_filter_spec.rb
 - spec/hash_filter_spec.rb
 - spec/inheritance_spec.rb