mutations 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60a9dcaccc2cded1876539ff36b62111b6bfdcec887494265fe4fa510c360ad5
-  data.tar.gz: 7a2bd2aacb4f8b9296e7f4a638fe42a1034ee8736a24a31d811580a87e4ecbe7
+  metadata.gz: c4a28329a36aca21130a7a521f6833ad47ce35f31d0c1014c432eafbdad667b5
+  data.tar.gz: 5b085b2e98b416ff440b6842b556bad82b7c6d38e233828f0a84a192dcb2ee0a
 SHA512:
-  metadata.gz: 756a1dd30f3affd27ef111ebfbdf066e3e056767f6a08a7b69f8c39831f977bb9ee96b82e2f729cc02d4f6bffa2ea04f8ad8e405b9b6855f7a3bc06a20a4039a
-  data.tar.gz: b18adcdba20934dda3555cb3b72d90e23cd81612e152991338dd750f2d4bbd57ced91037b9900c4d42f8d6090cf4fe662ca0e91c3dba64692a5d0f0e3f46cae3
+  metadata.gz: 80ceb34a91da980b81eae6f47e26c967a03c7a11d49afa7da6646236c7a39ccee2936471abb12d66a43269231cbff889b03ca01ed0c5978fffeedf11e8b2fcfb
+  data.tar.gz: ad443a9ce7ed66004ddf09454315902a0a47d161c9a732a70d0f26e532d000ba86a51f83da1dbbef08dc96145a322cf26834f02f1a8b92a341b15f6f2f387fec

data/.travis.yml

@@ -1,15 +1,14 @@
 language: ruby
-dist: trusty
-sudo: required
 before_install:
-  - gem install bundler # the default bundler version on travis is very old and causes 1.9.3 build issues
+  - gem install bundler || gem install bundler -v 1.17.3 # the default bundler version on travis is very old and causes 1.9.3 build issues
 rvm:
   - 1.9.3
-  - jruby-1.7.26
   - 2.0.0
   - 2.1.10
-  - 2.2.6
-  - 2.3.3
-  - 2.4.0
-  - jruby-9.1.7.0
-  - rbx-3
+  - 2.2.10
+  - 2.3.8
+  - 2.4.9
+  - 2.5.7
+  - 2.6.5
+  - 2.7.0
+  - jruby-9.2.10.0

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+0.9.1
+-----------
+ - Treat blank strings as nil when `strip` and `empty_is_nil` options are set (#148, @saverio-kantox)
+ - Don't use full key in nested error messages (#149, @eugeneius)
+ - Don't remove unknown characters in string filter (#150, @eugeneius)
+
 0.9.0
 -----------
  - Retain `_id` suffix in error keys (#129, @khalilovcmd)

data/Gemfile

@@ -1,8 +1,2 @@
 source 'http://rubygems.org'
 gemspec
-
-platforms :rbx do
-  gem 'rubysl', '~> 2.0'
-  gem 'psych'
-  gem 'rubinius-developer_tools'
-end

data/README.md

@@ -1,6 +1,6 @@
 # Mutations
 
-[![Build Status](https://travis-ci.org/cypriss/mutations.svg)](https://travis-ci.org/cypriss/mutations)
+[![Build Status](https://travis-ci.org/cypriss/mutations.svg?branch=master)](https://travis-ci.org/cypriss/mutations)
 [![Code Climate](https://codeclimate.com/github/cypriss/mutations.svg)](https://codeclimate.com/github/cypriss/mutations)
 
 Compose your business logic into commands that sanitize and validate input. Write safe, reusable, and maintainable code for Ruby and Rails apps.

data/Rakefile

@@ -2,7 +2,6 @@ require "bundler/gem_tasks"
 require "rake/testtask"
 Rake::TestTask.new(:test) do |test|
   test.libs << "spec"
-  # test.warning = true # Wow that outputs a lot of shit
   test.pattern = "spec/**/*_spec.rb"
 end
 

data/lib/mutations/array_filter.rb

@@ -1,8 +1,7 @@
 module Mutations
   class ArrayFilter < InputFilter
     def self.register_additional_filter(type_class, type_name)
-      define_method(type_name) do | *args, &block |
-        options = args[0] || {}
+      define_method(type_name) do |options = {}, &block|
         @element_filter = type_class.new(options, &block)
       end
     end

data/lib/mutations/command.rb

@@ -119,7 +119,7 @@ module Mutations
         inner = path.inject(errs) do |cur_errors,part|
           cur_errors[part.to_sym] ||= ErrorHash.new
         end
-        inner[last] = ErrorAtom.new(key, kind, :message => message)
+        inner[last] = ErrorAtom.new(last.to_sym, kind, :message => message)
       end
     end
 

data/lib/mutations/date_filter.rb

@@ -9,10 +9,6 @@ module Mutations
     }
 
     def filter(data)
-      if options[:empty_is_nil] && data == ""
-        data = nil
-      end
-
       # Handle nil case
       if data.nil?
         return [nil, nil] if options[:nils]
@@ -20,7 +16,13 @@ module Mutations
       end
 
       # Now check if it's empty:
-      return [data, :empty] if "" == data
+      if data == ""
+        if options[:empty_is_nil]
+          return [nil, (:nils unless options[:nils])]
+        else
+          return [data, :empty]
+        end
+      end
 
       if data.is_a?(Date) # Date and DateTime
         actual_date = data

data/lib/mutations/hash_filter.rb

@@ -1,10 +1,7 @@
 module Mutations
   class HashFilter < InputFilter
     def self.register_additional_filter(type_class, type_name)
-      define_method(type_name) do | *args, &block |
-        name = args[0]
-        options = args[1] || {}
-
+      define_method(type_name) do |name, options = {}, &block|
         @current_inputs[name.to_sym] = type_class.new(options, &block)
       end
     end

data/lib/mutations/integer_filter.rb

@@ -9,11 +9,6 @@ module Mutations
     }
 
     def filter(data)
-
-      if options[:empty_is_nil] && data == ""
-        data = nil
-      end
-
       # Handle nil case
       if data.nil?
         return [nil, nil] if options[:nils]
@@ -21,7 +16,13 @@ module Mutations
       end
 
       # Now check if it's empty:
-      return [data, :empty] if data == ""
+      if data == ""
+        if options[:empty_is_nil]
+          return [nil, (:nils unless options[:nils])]
+        else
+          return [data, :empty]
+        end
+      end
 
       # Ensure it's the correct data type (Integer)
       if !data.is_a?(Integer)

data/lib/mutations/string_filter.rb

@@ -11,14 +11,10 @@ module Mutations
       :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.
-      :allow_control_characters => false    # false removes unprintable characters from the string
+      :allow_control_characters => false    # false removes control characters from the string
     }
 
     def filter(data)
-      if options[:empty_is_nil] && data == ""
-        data = nil
-      end
-
       # Handle nil case
       if data.nil?
         return [nil, nil] if options[:nils]
@@ -31,15 +27,17 @@ module Mutations
       # Now ensure it's a string:
       return [data, :string] unless data.is_a?(String)
 
-      # At this point, data is a string. Now remove unprintable characters from the string:
-      data = data.gsub(/[^[:print:]\t\r\n]+/, ' ') unless options[:allow_control_characters]
+      # At this point, data is a string. Now remove control characters from the string:
+      data = data.gsub(/((?=[[:cntrl:]])[^\t\r\n])+/, ' ') unless options[:allow_control_characters]
 
       # Transform it using strip:
       data = data.strip if options[:strip]
 
       # Now check if it's blank:
       if data == ""
-        if options[:empty]
+        if options[:empty_is_nil]
+          return [nil, (:nils unless options[:nils])]
+        elsif options[:empty]
           return [data, nil]
         else
           return [data, :empty]

data/lib/mutations/version.rb

@@ -1,3 +1,3 @@
 module Mutations
-  VERSION = "0.9.0"
+  VERSION = "0.9.1"
 end

data/spec/array_filter_spec.rb

@@ -155,7 +155,7 @@ describe "Mutations::ArrayFilter" do
 
     assert_equal nil, errors[0]
     assert_equal nil, errors[1]
-    assert_equal ({"bar"=>:required}), errors[2].symbolic
+    assert_equal({"bar"=>:required}, errors[2].symbolic)
   end
 
   it "lets you pass arrays of arrays" do
@@ -224,7 +224,7 @@ describe "Mutations::ArrayFilter" do
     was = Mutations.cache_constants?
     Mutations.cache_constants = true
 
-    f = Mutations::ArrayFilter.new(:simple_models, class: "SimpleModel")
+    f = Mutations::ArrayFilter.new(:simple_models, :class => "SimpleModel")
 
     m = SimpleModel.new
     filtered, errors = f.filter([m])
@@ -246,7 +246,7 @@ describe "Mutations::ArrayFilter" do
     was = Mutations.cache_constants?
     Mutations.cache_constants = false
 
-    f = Mutations::ArrayFilter.new(:simple_models, class: "SimpleModel")
+    f = Mutations::ArrayFilter.new(:simple_models, :class => "SimpleModel")
 
     m = SimpleModel.new
     filtered, errors = f.filter([m])

data/spec/command_spec.rb

@@ -8,7 +8,7 @@ describe "Command" do
       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
 
@@ -16,7 +16,7 @@ describe "Command" do
       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
 
@@ -29,7 +29,7 @@ describe "Command" do
 
     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
+      assert_equal({:name => "John", :email => "john@gmail.com", :amount => 5}.stringify_keys, result)
     end
 
     it "should throw an exception with run!" do
@@ -77,14 +77,14 @@ describe "Command" do
       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})
 
       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 objects that are not hashes or directly mappable to hashes" do
@@ -104,14 +104,14 @@ describe "Command" do
     it 'should accept objects that are conceptually hashes' do
       class CustomPersonHash
         def to_hash
-          { name: 'John', email: 'john@example.com' }
+          { :name => 'John', :email => 'john@example.com' }
         end
       end
 
       outcome = SimpleCommand.run(CustomPersonHash.new)
 
       assert outcome.success?
-      assert_equal ({ name: "John", email: "john@example.com" }).stringify_keys, outcome.result
+      assert_equal({ :name => "John", :email => "john@example.com" }.stringify_keys, outcome.result)
     end
 
     it "should accept nothing at all" do
@@ -120,7 +120,7 @@ describe "Command" do
 
     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
+      assert_equal({:name => "John", :email => "john@gmail.com", :amount => 5}.stringify_keys, outcome.inputs)
     end
   end
 
@@ -137,7 +137,7 @@ describe "Command" do
 
     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
+      assert_equal({:name => "John", :email => "john@gmail.com"}, mutation.result)
     end
   end
 
@@ -155,7 +155,7 @@ describe "Command" do
 
     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
+      assert_equal({:name => "bob", :email => "bob@jones.com"}, mutation.result)
     end
   end
 
@@ -183,8 +183,8 @@ describe "Command" do
 
   describe "CustomErrorKeyCommand" do
     class CustomErrorKeyCommand < Mutations::Command
-      required { string :name, error_key: :other_name }
-      optional { string :email, min_length: 4, error_key: :other_email }
+      required { string :name, :error_key => :other_name }
+      optional { string :email, :min_length => 4, :error_key => :other_email }
     end
 
     it "should return the optional error key in the error message if required" do
@@ -196,7 +196,7 @@ describe "Command" do
     end
 
     it "should return the optional error key in the error message if optional" do
-      outcome = CustomErrorKeyCommand.run(email: "foo")
+      outcome = CustomErrorKeyCommand.run(:email => "foo")
 
       assert !outcome.success?
       assert_equal :min_length, outcome.errors.symbolic[:email]
@@ -223,6 +223,7 @@ describe "Command" do
       assert !outcome.success?
       assert_nil outcome.result
       assert_equal :is_a_bob, outcome.errors[:people].symbolic[:bob]
+      assert_equal "Bob is invalid", outcome.errors[:people].message[:bob]
     end
   end
 

data/spec/date_filter_spec.rb

@@ -21,12 +21,8 @@ describe "Mutations::DateFilter" do
     time = Time.now
     f = Mutations::DateFilter.new
     filtered, errors = f.filter(time)
-    if time.respond_to?(:to_date) # 1.8.7 doesn't support to_date
-      assert_equal time.to_date, filtered
-      assert_equal nil, errors
-    else
-      assert_equal :date, errors
-    end
+    assert_equal time.to_date, filtered
+    assert_equal nil, errors
   end
 
   it "checks if the given date is after a certain date" do

data/spec/default_spec.rb

@@ -16,13 +16,13 @@ describe 'Mutations - defaults' do
   it "should have a default if no value is passed" do
     outcome = DefaultCommand.run
     assert_equal true, outcome.success?
-    assert_equal ({"name" => "Bob Jones"}), outcome.result
+    assert_equal({"name" => "Bob Jones"}, outcome.result)
   end
 
   it "should have the passed value if a value is passed" do
     outcome = DefaultCommand.run(:name => "Fred")
     assert_equal true, outcome.success?
-    assert_equal ({"name" => "Fred"}), outcome.result
+    assert_equal({"name" => "Fred"}, outcome.result)
   end
 
   it "should be an error if nil is passed on a required field with a default" do

data/spec/errors_spec.rb

@@ -26,33 +26,33 @@ describe "Mutations - errors" do
     o = GivesErrors.run(:hash1 => 1, :arr1 => "bob")
 
     assert !o.success?
-    assert o.errors.is_a?(Mutations::ErrorHash)
-    assert o.errors[:str1].is_a?(Mutations::ErrorAtom)
-    assert o.errors[:str2].is_a?(Mutations::ErrorAtom)
+    assert_kind_of Mutations::ErrorHash, o.errors
+    assert_kind_of Mutations::ErrorAtom, o.errors[:str1]
+    assert_kind_of Mutations::ErrorAtom, o.errors[:str2]
     assert_nil o.errors[:int1]
-    assert o.errors[:hash1].is_a?(Mutations::ErrorAtom)
-    assert o.errors[:arr1].is_a?(Mutations::ErrorAtom)
+    assert_kind_of Mutations::ErrorAtom, o.errors[:hash1]
+    assert_kind_of Mutations::ErrorAtom, o.errors[:arr1]
   end
 
   it "returns an ErrorHash for nested hashes" do
     o = GivesErrors.run(:hash1 => {:bool1 => "poop"})
 
     assert !o.success?
-    assert o.errors.is_a?(Mutations::ErrorHash)
-    assert o.errors[:hash1].is_a?(Mutations::ErrorHash)
-    assert o.errors[:hash1][:bool1].is_a?(Mutations::ErrorAtom)
-    assert o.errors[:hash1][:bool2].is_a?(Mutations::ErrorAtom)
+    assert_kind_of Mutations::ErrorHash, o.errors
+    assert_kind_of Mutations::ErrorHash, o.errors[:hash1]
+    assert_kind_of Mutations::ErrorAtom, o.errors[:hash1][:bool1]
+    assert_kind_of Mutations::ErrorAtom, o.errors[:hash1][:bool2]
   end
 
   it "returns an ErrorArray for errors in arrays" do
     o = GivesErrors.run(:str1 => "a", :str2 => "opt1", :arr1 => ["bob", 1, "sally"])
 
     assert !o.success?
-    assert o.errors.is_a?(Mutations::ErrorHash)
-    assert o.errors[:arr1].is_a?(Mutations::ErrorArray)
-    assert o.errors[:arr1][0].is_a?(Mutations::ErrorAtom)
+    assert_kind_of Mutations::ErrorHash, o.errors
+    assert_kind_of Mutations::ErrorArray, o.errors[:arr1]
+    assert_kind_of Mutations::ErrorAtom, o.errors[:arr1][0]
     assert_nil o.errors[:arr1][1]
-    assert o.errors[:arr1][2].is_a?(Mutations::ErrorAtom)
+    assert_kind_of Mutations::ErrorAtom, o.errors[:arr1][2]
   end
 
   describe "error messages" do
@@ -97,7 +97,7 @@ describe "Mutations - errors" do
       expected = ["Str1 can't be blank", "Str2 isn't an option", "Int1 isn't an integer", "Bool1 isn't a boolean", "Bool2 is required", "Arr1[0] isn't an integer", "Arr1[2] isn't an integer"]
 
       assert_equal expected.size, @outcome.errors.message_list.size
-      expected.each { |e| assert @outcome.errors.message_list.include?(e) }
+      expected.each { |e| assert_includes @outcome.errors.message_list, e }
     end
   end
 

data/spec/file_filter_spec.rb

@@ -8,16 +8,12 @@ describe "Mutations::FileFilter" do
     attr_accessor :content_type, :original_filename
   end
 
-  # NOTE: Ruby 1.8.7 doesn't have file.size. Mutations need file to respond to size.
-  # Therefore, in 1.8.7 File objects are invalid files.
-  if File.new("README.md").respond_to?(:size)
-    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 - 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
@@ -32,7 +28,7 @@ describe "Mutations::FileFilter" do
     file = Tempfile.new("bob")
     f = Mutations::FileFilter.new
     filtered, errors = f.filter(file)
-    assert filtered.is_a?(Tempfile) # NOTE: 1.9.3 and 1.8.7 treat == and eql? differently
+    assert_equal file, filtered
     assert_equal nil, errors
   end
 

data/spec/hash_filter_spec.rb

@@ -8,7 +8,7 @@ describe "Mutations::HashFilter" do
       string :foo
     end
     filtered, errors = hf.filter(:foo => "bar")
-    assert_equal ({"foo" => "bar"}), filtered
+    assert_equal({"foo" => "bar"}, filtered)
     assert_equal nil, errors
   end
 
@@ -37,7 +37,7 @@ describe "Mutations::HashFilter" do
       string :*
     end
     filtered, errors = hf.filter(:foo => "bar", :baz => "ban")
-    assert_equal ({"foo" => "bar", "baz" => "ban"}), filtered
+    assert_equal({"foo" => "bar", "baz" => "ban"}, filtered)
     assert_equal nil, errors
   end
 
@@ -46,7 +46,7 @@ describe "Mutations::HashFilter" do
       float :foo
     end
     filtered, errors = hf.filter(:foo => 3.14)
-    assert_equal ({"foo" => 3.14}), filtered
+    assert_equal({"foo" => 3.14}, filtered)
     assert_equal nil, errors
   end
 
@@ -55,7 +55,7 @@ describe "Mutations::HashFilter" do
       duck :foo, :methods => [:length]
     end
     filtered, errors = hf.filter(:foo => "123")
-    assert_equal ({"foo" => "123"}), filtered
+    assert_equal({"foo" => "123"}, filtered)
     assert_equal nil, errors
   end
 
@@ -74,7 +74,7 @@ describe "Mutations::HashFilter" do
       file :foo
     end
     filtered, errors = hf.filter(:foo => sio)
-    assert_equal ({"foo" => sio}), filtered
+    assert_equal({"foo" => sio}, filtered)
     assert_equal nil, errors
   end
 
@@ -83,7 +83,7 @@ describe "Mutations::HashFilter" do
       string :*
     end
     _filtered, errors = hf.filter(:foo => [])
-    assert_equal ({"foo" => :string}), errors.symbolic
+    assert_equal({"foo" => :string}, errors.symbolic)
   end
 
   it "allows a mix of specific keys and then wildcards" do
@@ -92,7 +92,7 @@ describe "Mutations::HashFilter" do
       integer :*
     end
     filtered, errors = hf.filter(:foo => "bar", :baz => "4")
-    assert_equal ({"foo" => "bar", "baz" => 4}), filtered
+    assert_equal({"foo" => "bar", "baz" => 4}, filtered)
     assert_equal nil, errors
   end
 
@@ -102,7 +102,7 @@ describe "Mutations::HashFilter" do
       integer :*
     end
     _filtered, errors = hf.filter(:foo => "bar", :baz => "poopin")
-    assert_equal ({"baz" => :integer}), errors.symbolic
+    assert_equal({"baz" => :integer}, errors.symbolic)
   end
 
   describe "optional params and nils" do
@@ -117,7 +117,7 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar")
-      assert_equal ({"foo" => "bar"}), filtered
+      assert_equal({"foo" => "bar"}, filtered)
       assert_equal nil, errors
     end
 
@@ -132,7 +132,7 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => nil)
-      assert_equal ({"foo" => "bar"}), filtered
+      assert_equal({"foo" => "bar"}, filtered)
       assert_equal nil, errors
     end
 
@@ -147,7 +147,7 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => nil)
-      assert_equal ({"foo" => "bar", "bar" => nil}), filtered
+      assert_equal({"foo" => "bar", "bar" => nil}, filtered)
       assert_equal nil, errors
     end
   end
@@ -164,7 +164,7 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => "")
-      assert_equal ({"foo" => "bar"}), filtered
+      assert_equal({"foo" => "bar"}, filtered)
       assert_equal nil, errors
     end
     
@@ -179,7 +179,7 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => " ")
-      assert_equal ({"foo" => "bar"}), filtered
+      assert_equal({"foo" => "bar"}, filtered)
       assert_equal nil, errors
     end
     
@@ -194,7 +194,7 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => " ")
-      assert_equal ({"foo" => "bar", "bar" => " "}), filtered
+      assert_equal({"foo" => "bar", "bar" => " "}, filtered)
       assert_equal nil, errors
     end
 
@@ -209,7 +209,7 @@ describe "Mutations::HashFilter" do
       end
 
       _filtered, errors = hf.filter(:foo => "bar", :bar => "")
-      assert_equal ({"bar" => :empty}), errors.symbolic
+      assert_equal({"bar" => :empty}, errors.symbolic)
     end
 
     it "bar is optional -- discards empty -- now with wildcards" do
@@ -223,7 +223,7 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => "", :baz => "\t")
-      assert_equal ({"foo" => "bar"}), filtered
+      assert_equal({"foo" => "bar"}, filtered)
       assert_equal nil, errors
     end
   end
@@ -240,7 +240,7 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => "baz")
-      assert_equal ({"foo" => "bar"}), filtered
+      assert_equal({"foo" => "bar"}, filtered)
       assert_equal nil, errors
     end
 
@@ -255,7 +255,7 @@ describe "Mutations::HashFilter" do
       end
 
       filtered, errors = hf.filter(:foo => "bar", :bar => "baz", :wat => 1)
-      assert_equal ({"foo" => "bar", "wat" => 1}), filtered
+      assert_equal({"foo" => "bar", "wat" => 1}, filtered)
       assert_equal nil, errors
     end
 
@@ -268,7 +268,7 @@ describe "Mutations::HashFilter" do
       end
 
       _filtered, errors = hf.filter(:foo => "bar")
-      assert_equal ({"foo" => :integer}), errors.symbolic
+      assert_equal({"foo" => :integer}, errors.symbolic)
     end
   end
 

data/spec/mutations_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe 'Mutations' do
 
   it 'should have a version' do
-    assert Mutations::VERSION.is_a?(String)
+    assert_kind_of String, Mutations::VERSION
   end
 
 end

data/spec/string_filter_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe "Mutations::StringFilter" do
@@ -16,7 +18,7 @@ describe "Mutations::StringFilter" do
     assert_equal nil, errors
   end
 
-  it "allows fixnums" do
+  it "allows numbers" do
     sf = Mutations::StringFilter.new
     filtered, errors = sf.filter(1)
     assert_equal "1", filtered
@@ -93,7 +95,21 @@ describe "Mutations::StringFilter" do
     assert_equal :empty, errors
   end
 
-  it "considers strings that contain only unprintable characters to be invalid" do
+  it "considers stripped strings that are blank to be nil if empty_is_nil option is used" do
+    sf = Mutations::StringFilter.new(:strip => true, :empty_is_nil => true, :nils => true)
+    filtered, errors = sf.filter("   ")
+    assert_equal nil, filtered
+    assert_equal nil, errors
+  end
+
+  it "considers stripped strings that are blank to be invalid if empty_is_nil option is used" do
+    sf = Mutations::StringFilter.new(:strip => true, :empty_is_nil => true)
+    filtered, errors = sf.filter("   ")
+    assert_equal nil, filtered
+    assert_equal :nils, errors
+  end
+
+  it "considers strings that contain only control characters to be invalid" do
     sf = Mutations::StringFilter.new(:empty => false)
     filtered, errors = sf.filter("\u0000\u0000")
     assert_equal "", filtered
@@ -172,7 +188,7 @@ describe "Mutations::StringFilter" do
 
   it "converts bigdecimals to strings" do
     sf = Mutations::StringFilter.new(:strict => false)
-    filtered, errors = sf.filter(BigDecimal.new("0.0001"))
+    filtered, errors = sf.filter(BigDecimal("0.0001"))
     assert_equal("0.1E-3", filtered.upcase)
     assert_equal nil, errors
   end
@@ -207,7 +223,7 @@ describe "Mutations::StringFilter" do
 
   it "disallows bigdecimals" do
     sf = Mutations::StringFilter.new(:strict => true)
-    big_decimal = BigDecimal.new("0.0001")
+    big_decimal = BigDecimal("0.0001")
     filtered, errors = sf.filter(big_decimal)
     assert_equal big_decimal, filtered
     assert_equal :string, errors
@@ -227,14 +243,14 @@ describe "Mutations::StringFilter" do
     assert_equal :string, errors
   end
 
-  it "removes unprintable characters" do
+  it "removes control characters" do
     sf = Mutations::StringFilter.new(:allow_control_characters => false)
     filtered, errors = sf.filter("Hello\u0000\u0000World!")
     assert_equal "Hello World!", filtered
     assert_equal nil, errors
   end
 
-  it "doesn't remove unprintable characters" do
+  it "doesn't remove control characters" do
     sf = Mutations::StringFilter.new(:allow_control_characters => true)
     filtered, errors = sf.filter("Hello\u0000\u0000World!")
     assert_equal "Hello\u0000\u0000World!", filtered
@@ -248,4 +264,11 @@ describe "Mutations::StringFilter" do
     assert_equal nil, errors
   end
 
+  it "doesn't remove emoji" do
+    sf = Mutations::StringFilter.new(:allow_control_characters => false)
+    filtered, errors = sf.filter("😂🙂🙃🤣🤩🥰🥱")
+    assert_equal "😂🙂🙃🤣🤩🥰🥱", filtered
+    assert_equal nil, errors
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mutations
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Jonathan Novak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-05 00:00:00.000000000 Z
+date: 2020-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -127,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Compose your business logic into commands that sanitize and validate input.