mutations 0.5.12 → 0.6.0

data/lib/mutations/hash_filter.rb

@@ -1,7 +1,16 @@
 module Mutations
   class HashFilter < InputFilter
+    def self.register_additional_filter(type_class, type_name)
+      define_method(type_name) do | *args |
+        name = args[0]
+        options = args[1] || {}
+
+        @current_inputs[name.to_sym] = type_class.new(options)
+      end
+    end
+
     @default_options = {
-      nils: false,            # true allows an explicit nil to be valid. Overrides any other options
+      :nils => false,            # true allows an explicit nil to be valid. Overrides any other options
     }
 
     attr_accessor :optional_inputs
@@ -48,38 +57,12 @@ module Mutations
       @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 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
 
     def model(name, options = {})
-      name_sym = name.to_sym
-      @current_inputs[name_sym] = ModelFilter.new(name_sym, options)
+      @current_inputs[name.to_sym] = ModelFilter.new(name.to_sym, options)
     end
 
     def array(name, options = {}, &block)
@@ -170,4 +153,4 @@ module Mutations
       end
     end
   end
-end
+end

data/lib/mutations/integer_filter.rb

@@ -1,10 +1,10 @@
 module Mutations
-  class IntegerFilter < InputFilter
+  class IntegerFilter < AdditionalFilter
     @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
-      in: nil            # Can be an array like %w(3 4 5)
+      :nils => false,       # true allows an explicit nil to be valid. Overrides any other options
+      :min => nil,          # lowest value, inclusive
+      :max => nil,          # highest value, inclusive
+      :in => nil            # Can be an array like %w(3 4 5)
     }
 
     def filter(data)

data/lib/mutations/model_filter.rb

@@ -1,35 +1,40 @@
 module Mutations
   class ModelFilter < InputFilter
     @default_options = {
-      nils: false,        # true allows an explicit nil to be valid. Overrides any other options
-      class: nil,         # default is the attribute name.to_s.camelize.constantize.  This overrides it with class or class.constantize
-      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
+      :nils => false,        # true allows an explicit nil to be valid. Overrides any other options
+      :class => nil,         # default is the attribute name.to_s.camelize.constantize.  This overrides it with class or class.constantize
+      :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
     end
-    
+
     # Initialize the model class and builder
     def initialize_constants!
       @initialize_constants ||= begin
         class_const = options[:class] || @name.to_s.camelize
         class_const = class_const.constantize if class_const.is_a?(String)
-        self.options[:class] = class_const
+        options[:class] = class_const
 
         if options[:builder]
           options[:builder] = options[:builder].constantize if options[:builder].is_a?(String)
         end
-        
+
         true
       end
+      
+      unless Mutations.cache_constants?
+        options[:class] = options[:class].to_s.constantize if options[:class]
+        options[:builder] = options[:builder].to_s.constantize if options[:builder]
+      end
     end
 
     def filter(data)
       initialize_constants!
-      
+
       # Handle nil case
       if data.nil?
         return [nil, nil] if options[:nils]

data/lib/mutations/outcome.rb

@@ -1,7 +1,7 @@
 module Mutations
   class Outcome
     attr_reader :result, :errors, :inputs
-    
+
     def initialize(is_success, result, errors, inputs)
       @success, @result, @errors, @inputs = is_success, result, errors, inputs
     end

data/lib/mutations/string_filter.rb

@@ -1,15 +1,15 @@
 module Mutations
-  class StringFilter < InputFilter
+  class StringFilter < AdditionalFilter
     @default_options = {
-      strip: true,          # true calls data.strip if data is a string
-      strict: false,        # If false, then symbols, numbers, and booleans are converted to a string with to_s. # TODO: TEST
-      nils: false,          # true allows an explicit nil to be valid. Overrides any other options
-      empty: false,         # false disallows "".  true allows "" and overrides any other validations (b/c they couldn't be true if it's empty)
-      min_length: nil,      # Can be a number like 5, meaning that 5 codepoints are required
-      max_length: nil,      # Can be a number like 10, meaning that at most 10 codepoints are permitted
-      matches: nil,         # Can be a regexp
-      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.
+      :strip => true,          # true calls data.strip if data is a string
+      :strict => false,        # If false, then symbols, numbers, and booleans are converted to a string with to_s. # TODO: TEST
+      :nils => false,          # true allows an explicit nil to be valid. Overrides any other options
+      :empty => false,         # false disallows "".  true allows "" and overrides any other validations (b/c they couldn't be true if it's empty)
+      :min_length => nil,      # Can be a number like 5, meaning that 5 codepoints are required
+      :max_length => nil,      # Can be a number like 10, meaning that at most 10 codepoints are permitted
+      :matches => nil,         # Can be a regexp
+      :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)

data/lib/mutations/version.rb

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

data/mutations.gemspec

@@ -15,6 +15,4 @@ 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/additional_filter_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe "Mutations::AdditionalFilter" do
+
+  describe "Additional Filter" do
+    module Mutations
+      class SometestFilter < Mutations::AdditionalFilter
+        @default_options = {
+          :nils => false
+        }
+
+        def filter(data)
+          return [data, nil]
+        end
+      end
+    end
+
+    class TestCommandUsingAdditionalFilters < Mutations::Command
+      required do
+        sometest :first_name
+      end
+
+      def execute
+        { :first_name => first_name }
+      end
+    end
+
+    it "should recognize additional filters" do
+      outcome = TestCommandUsingAdditionalFilters.run(:first_name => "John")
+      assert outcome.success?
+      assert_equal nil, outcome.errors
+    end
+
+    class TestCommandUsingAdditionalFiltersInHashes < Mutations::Command
+      required do
+        hash :a_hash do
+          sometest :first_name
+        end
+      end
+
+      def execute
+        { :a_hash => a_hash }
+      end
+    end
+
+    it "should be useable in hashes" do
+      outcome = TestCommandUsingAdditionalFiltersInHashes.run(
+        :a_hash => { :first_name => "John" } 
+      )
+
+      assert outcome.success?
+      assert_equal nil, outcome.errors
+    end
+
+    class TestCommandUsingAdditionalFiltersInArrays < Mutations::Command
+      required do
+        array :an_array do
+          sometest
+        end
+      end
+
+      def execute
+        { :an_array => an_array }
+      end
+    end
+
+    it "should be useable in arrays" do
+      outcome = TestCommandUsingAdditionalFiltersInArrays.run(
+        :an_array => [ "John", "Bill" ]
+      )
+
+      assert outcome.success?
+      assert_equal nil, outcome.errors
+    end
+  end
+end

data/spec/array_filter_spec.rb

@@ -1,4 +1,4 @@
-require_relative 'spec_helper'
+require 'spec_helper'
 require 'stringio'
 
 describe "Mutations::ArrayFilter" do
@@ -12,42 +12,42 @@ describe "Mutations::ArrayFilter" do
 
   it "considers non-arrays to be invalid" do
     f = Mutations::ArrayFilter.new(:arr)
-    ['hi', true, 1, {a: "1"}, Object.new].each do |thing|
+    ['hi', true, 1, {:a => "1"}, Object.new].each do |thing|
       filtered, errors = f.filter(thing)
       assert_equal :array, errors
     end
   end
 
   it "considers nil to be invalid" do
-    f = Mutations::ArrayFilter.new(:arr, nils: false)
+    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)
+    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)
+    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')
+    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)
+    f = Mutations::ArrayFilter.new(:arr, :class => Fixnum)
     filtered, errors = f.filter([1, "bob"])
     assert_equal [nil, :class], errors.symbolic
     assert_equal [1,"bob"], filtered
@@ -56,13 +56,13 @@ describe "Mutations::ArrayFilter" do
   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"}])
+    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 }
+    f = Mutations::ArrayFilter.new(:arr, :arrayize => true) { string }
 
     filtered, errors = f.filter("foo")
     assert_equal ["foo"], filtered
@@ -70,7 +70,7 @@ describe "Mutations::ArrayFilter" do
   end
 
   it "lets you array-ize an empty string" do
-    f = Mutations::ArrayFilter.new(:arr, arrayize: true) { string }
+    f = Mutations::ArrayFilter.new(:arr, :arrayize => true) { string }
 
     filtered, errors = f.filter("")
     assert_equal [], filtered
@@ -78,7 +78,7 @@ describe "Mutations::ArrayFilter" do
   end
 
   it "lets you pass integers in arrays" do
-    f = Mutations::ArrayFilter.new(:arr) { integer min: 4 }
+    f = Mutations::ArrayFilter.new(:arr) { integer :min => 4 }
 
     filtered, errors = f.filter([5,6,1,"bob"])
     assert_equal [5,6,1,"bob"], filtered
@@ -86,21 +86,29 @@ describe "Mutations::ArrayFilter" do
   end
 
   it "lets you pass floats in arrays" do
-    f = Mutations::ArrayFilter.new(:float) { float min: 4.0 }
+    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 ducks in arrays" do
-    f = Mutations::ArrayFilter.new(:arr) { duck(methods: :length) }
+    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 dates in arrays" do
+    f = Mutations::ArrayFilter.new(:arr) {date(:format => "%Y-%m-%d")}
+
+    filtered, errors = f.filter(["2000-1-1", Date.new(2000, 1, 1), "2000-20-1"])
+    assert_equal ["2000-1-1", Date.new(2000, 1, 1), "2000-20-1"], filtered
+    assert_equal [nil, nil, :date], errors.symbolic
+  end
+
   it "lets you pass files in arrays" do
     sio = StringIO.new("bob")
     f = Mutations::ArrayFilter.new(:arr) { file }
@@ -140,7 +148,7 @@ describe "Mutations::ArrayFilter" do
       end
     end
 
-    filtered, errors = f.filter([{foo: "f", bar: 3, baz: true}, {foo: "f", bar: 3}, {foo: "f"}])
+    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]
@@ -173,4 +181,4 @@ describe "Mutations::ArrayFilter" do
     assert_equal ["Array[2] isn't a string", "Array[0] can't be blank"], errors.message_list
   end
 
-end
+end

data/spec/boolean_filter_spec.rb

@@ -1,4 +1,4 @@
-require_relative 'spec_helper'
+require 'spec_helper'
 
 describe "Mutations::BooleanFilter" do
 
@@ -15,21 +15,21 @@ describe "Mutations::BooleanFilter" do
 
   it "considers non-booleans to be invalid" do
     f = Mutations::BooleanFilter.new
-    [[true], {a: "1"}, Object.new].each do |thing|
+    [[true], {:a => "1"}, Object.new].each do |thing|
       filtered, errors = f.filter(thing)
       assert_equal :boolean, errors
     end
   end
 
   it "considers nil to be invalid" do
-    f = Mutations::BooleanFilter.new(nils: false)
+    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)
+    f = Mutations::BooleanFilter.new(:nils => true)
     filtered, errors = f.filter(nil)
     assert_equal nil, filtered
     assert_equal nil, errors
@@ -52,4 +52,4 @@ describe "Mutations::BooleanFilter" do
       assert_equal :boolean, errors
     end
   end
-end
+end

data/spec/command_spec.rb

@@ -1,67 +1,67 @@
-require_relative 'spec_helper'
+require '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)
+      outcome = SimpleCommand.run(:name => "John", :email => "john@gmail.com", :amount => 5)
 
       assert outcome.success?
-      assert_equal ({name: "John", email: "john@gmail.com", amount: 5}).stringify_keys, outcome.result
+      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)
+      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 ({: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")
+      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
+      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")
+        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")
+      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")
+      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})
+      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
+      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})
+      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
+      assert_equal ({:name => "John", :email => "bob@jones.com", :amount => 5}).stringify_keys, outcome.result
     end
 
     it "shouldn't accept non-hashes" do
@@ -74,17 +74,17 @@ describe "Command" do
       end
 
       assert_raises ArgumentError do
-        outcome = SimpleCommand.run({name: "John"}, 1)
+        outcome = SimpleCommand.run({:name => "John"}, 1)
       end
     end
 
     it "should accept nothing at all" do
       SimpleCommand.run # make sure nothing is raised
     end
-    
+
     it "should return the filtered inputs in the outcome" do
-      outcome = SimpleCommand.run(name: " John ", email: "john@gmail.com", amount: "5")
-      assert_equal ({name: "John", email: "john@gmail.com", amount: 5}).stringify_keys, outcome.inputs
+      outcome = SimpleCommand.run(:name => " John ", :email => "john@gmail.com", :amount => "5")
+      assert_equal ({:name => "John", :email => "john@gmail.com", :amount => 5}).stringify_keys, outcome.inputs
     end
   end
 
@@ -95,13 +95,13 @@ describe "Command" do
       optional { string :email }
 
       def execute
-        {name: name, email: email}
+        {: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
+      mutation = EigenCommand.run(:name => "John", :email => "john@gmail.com")
+      assert_equal ({:name => "John", :email => "john@gmail.com"}), mutation.result
     end
   end
 
@@ -113,13 +113,13 @@ describe "Command" do
 
       def execute
         self.name, self.email = "bob", "bob@jones.com"
-        {name: inputs[:name], email: inputs[:email]}
+        {: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
+      mutation = MutatatedCommand.run(:name => "John", :email => "john@gmail.com")
+      assert_equal ({:name => "bob", :email => "bob@jones.com"}), mutation.result
     end
   end
 
@@ -137,7 +137,7 @@ describe "Command" do
     end
 
     it "should let you add errors" do
-      outcome = ErrorfulCommand.run(name: "John", email: "john@gmail.com")
+      outcome = ErrorfulCommand.run(:name => "John", :email => "john@gmail.com")
 
       assert !outcome.success?
       assert_nil outcome.result
@@ -163,7 +163,7 @@ describe "Command" do
     end
 
     it "should let you merge errors" do
-      outcome = ErrorfulCommand.run(name: "John", email: "john@gmail.com")
+      outcome = ErrorfulCommand.run(:name => "John", :email => "john@gmail.com")
 
       assert !outcome.success?
       assert_nil outcome.result
@@ -194,9 +194,9 @@ describe "Command" do
     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")
-      assert_equal 3, PresentCommand.run!(name: "John")
+      assert_equal 1, PresentCommand.run!(:name => "John", :email => "john@gmail.com")
+      assert_equal 2, PresentCommand.run!(:email => "john@gmail.com")
+      assert_equal 3, PresentCommand.run!(:name => "John")
       assert_equal 4, PresentCommand.run!
     end
   end