normatron 0.3.3 → 0.3.4

data/README.md

@@ -210,8 +210,8 @@ To apply the normalizations without doing validations or persistence, just call
 
 Create a new module with the following characteristics:
 
-* Having a module method called evaluate
-* The evaluate method must receive at least one argument
+* Having a module method called `call`
+* The `call` method must receive at least one argument
 * The first argument must be the value to be filtered
 
 Here is an example:
@@ -220,7 +220,7 @@ Here is an example:
 # ./lib/my_filters/emoticon_filter.rb
 module MyFilters
   module EmoticonFilter
-    def self.evaluate(value, type)
+    def self.call(value, type)
       emot = (type == :sad) ? ":(" : ":D"
       value + emot
     end

data/lib/normatron/extensions/active_record.rb

@@ -34,6 +34,8 @@ module Normatron
             new_filters = Normatron.build_hash(options[:with])
           end
 
+          @normalize_rules ||= {}
+
           # Append new filters to rules
           @normalize_rules =
           args.reduce(@normalize_rules) do |hash, att|
@@ -56,7 +58,7 @@ module Normatron
               if self.respond_to? filter
                 value = send(filter, value, *args)
               elsif listed_filters[filter].kind_of? Module
-                value = listed_filters[filter].evaluate(value, *args)
+                value = listed_filters[filter].call(value, *args)
               elsif listed_filters[filter].kind_of? Proc
                 value = listed_filters[filter].call(value, *args)
               else

data/lib/normatron/filters/ascii_filter.rb

@@ -7,8 +7,8 @@ module Normatron
     # Converts Unicode(and accented ASCII) characters to their plain-text ASCII equivalents.
     # 
     # @example Out of box
-    #   AsciiFilter.evaluate("EVOLUÇÃO")  #=> "EVOLUCAO"
-    #   AsciiFilter.evaluate("⠋⠗⠁⠝⠉⠑")  #=> "france"
+    #   AsciiFilter.call("EVOLUÇÃO")  #=> "EVOLUCAO"
+    #   AsciiFilter.call("⠋⠗⠁⠝⠉⠑")  #=> "france"
     #
     # @example Using as model normalizer
     #   normalize :attribute_a, :with => :ascii
@@ -24,7 +24,7 @@ module Normatron
       #
       # @param  input [String] The String to be filtered
       # @return [String] A new transliterated String
-      def self.evaluate(input)
+      def self.call(input)
         input.kind_of?(String) ? Stringex::Unidecoder.decode(input) : input
       end
     end

data/lib/normatron/filters/blank_filter.rb

@@ -5,11 +5,11 @@ module Normatron
     # Returns nil for a blank string or the string itself otherwise.
     # 
     # @example Out of box
-    #   BlankFilter.evaluate("")            #=> nil
-    #   BlankFilter.evaluate("     ")       #=> nil
-    #   BlankFilter.evaluate("  \n ")       #=> nil
-    #   BlankFilter.evaluate("1")           #=> "1"
-    #   BlankFilter.evaluate("It's blank?") #=> "It's blank?"
+    #   BlankFilter.call("")            #=> nil
+    #   BlankFilter.call("     ")       #=> nil
+    #   BlankFilter.call("  \n ")       #=> nil
+    #   BlankFilter.call("1")           #=> "1"
+    #   BlankFilter.call("It's blank?") #=> "It's blank?"
     #
     # @example Using as model normalizer
     #   normalize :attribute_a, :with => :blank
@@ -25,7 +25,7 @@ module Normatron
       #
       # @param  input [String] The String to be filtered
       # @return [String, nil] The object itself or nil
-      def self.evaluate(input)
+      def self.call(input)
         input.kind_of?(String) && input.blank? ? nil : input
       end
     end

data/lib/normatron/filters/camelize_filter.rb

@@ -18,9 +18,9 @@ module Normatron
     # but it affects UTF-8 characters too.
     # 
     # @example Out of box
-    #   CamelizeFilter.evaluate("active_record/errors")         #=> "ActiveRecord::Errors"
-    #   CamelizeFilter.evaluate("active_record/errors", :upper) #=> "ActiveRecord::Errors"
-    #   CamelizeFilter.evaluate("active_record/errors", :lower) #=> "activeRecord::Errors"
+    #   CamelizeFilter.call("active_record/errors")         #=> "ActiveRecord::Errors"
+    #   CamelizeFilter.call("active_record/errors", :upper) #=> "ActiveRecord::Errors"
+    #   CamelizeFilter.call("active_record/errors", :lower) #=> "activeRecord::Errors"
     #
     # @example Using as model normalizer
     #   normalize :attribute_a, :with => :camelize
@@ -43,7 +43,7 @@ module Normatron
       # @param  input [String] The String to be filtered
       # @param  camel [Symbol] @:lower@ for lowerCamelCase or @:upper@ for UpperCamelCase
       # @return [String] A new camelized String
-      def self.evaluate(input, camel = :upper)
+      def self.call(input, camel = :upper)
         return input unless input.kind_of?(String)
 
         string = mb_send(:downcase, input)

data/lib/normatron/filters/capitalize_filter.rb

@@ -7,9 +7,9 @@ module Normatron
     # Makes the first character uppercase and all remaining characters lowercase.
     # 
     # @example Out of box
-    #   CapitalizeFilter.evaluate("KEEP IT SIMPLE")  #=> "Keep it simple"
-    #   CapitalizeFilter.evaluate("keep it simple")  #=> "Keep it simple"
-    #   CapitalizeFilter.evaluate(" KEEP IT SIMPLE") #=> " keep it simple"
+    #   CapitalizeFilter.call("KEEP IT SIMPLE")  #=> "Keep it simple"
+    #   CapitalizeFilter.call("keep it simple")  #=> "Keep it simple"
+    #   CapitalizeFilter.call(" KEEP IT SIMPLE") #=> " keep it simple"
     #
     # @example Using as model normalizer
     #   normalize :attribute_a, :with => :capitalize
@@ -27,7 +27,7 @@ module Normatron
       #
       # @param  input [String] The String to be filtered
       # @return [String] A new capitalized String
-      def self.evaluate(input)
+      def self.call(input)
         input.kind_of?(String) ? mb_send(:capitalize, input) : input
       end
     end

data/lib/normatron/filters/chomp_filter.rb

@@ -7,11 +7,11 @@ module Normatron
     # characters (that is it will remove @\n@, @\r@, and @\r\n@).
     # 
     # @example Out of box
-    #   ChompFilter.evaluate("Bon Scott\n")         #=> "Bon Scott"
-    #   ChompFilter.evaluate("Bon Scott\r")         #=> "Bon Scott"
-    #   ChompFilter.evaluate("Bon Scott\r\n")       #=> "Bon Scott"
-    #   ChompFilter.evaluate("Bon Scott\n\r")       #=> "Bon Scott\n"
-    #   ChompFilter.evaluate("Bon Scott", " Scott") #=> "Bon"
+    #   ChompFilter.call("Bon Scott\n")         #=> "Bon Scott"
+    #   ChompFilter.call("Bon Scott\r")         #=> "Bon Scott"
+    #   ChompFilter.call("Bon Scott\r\n")       #=> "Bon Scott"
+    #   ChompFilter.call("Bon Scott\n\r")       #=> "Bon Scott\n"
+    #   ChompFilter.call("Bon Scott", " Scott") #=> "Bon"
     #
     # @example Using as model normalizer
     #   normalize :attribute_a, :with => :chomp
@@ -32,7 +32,7 @@ module Normatron
       # @param  input     [String] The String to be filtered
       # @param  separator [String] The separator used to chomp input
       # @return [String] A new chopped String
-      def self.evaluate(input, separator=$/)
+      def self.call(input, separator=$/)
         input.kind_of?(String) ? input.chomp(separator) : input
       end
     end

data/lib/normatron/filters/dasherize_filter.rb

@@ -7,7 +7,7 @@ module Normatron
     # Replaces all underscores with dashes.
     # 
     # @example Out of box
-    #   DasherizeFilter.evaluate("monty_python") #=> "monty-python"
+    #   DasherizeFilter.call("monty_python") #=> "monty-python"
     #
     # @example Using as model normalizer
     #   normalize :attribute_a, :with => :dasherize
@@ -23,7 +23,7 @@ module Normatron
       #
       # @param  input [String] The String to be filtered
       # @return [String] A new dasherized String
-      def self.evaluate(input)
+      def self.call(input)
         input.kind_of?(String) ? input.dasherize : input
       end
     end

data/lib/normatron/filters/downcase_filter.rb

@@ -7,7 +7,7 @@ module Normatron
     # Lowercase all characters.
     # 
     # @example Out of box
-    #   DowncaseFilter.evaluate("NOTHING ELSE MATTERS") #=> "nothing else matters"
+    #   DowncaseFilter.call("NOTHING ELSE MATTERS") #=> "nothing else matters"
     #
     # @example Using as ActiveRecord::Base normalizer
     #   normalize :attribute_a, :with => :downcase
@@ -27,7 +27,7 @@ module Normatron
       #
       # @param input [String] The String to be filtered
       # @return [String] A new lowercased String
-      def self.evaluate(input)
+      def self.call(input)
         input.kind_of?(String) ? mb_send(:downcase, input) : input
       end
     end

data/lib/normatron/filters/dump_filter.rb

@@ -6,10 +6,10 @@ module Normatron
     # special characters escaped.
     # 
     # @example Out of box
-    #   DumpFilter.evaluate("I'm not\na \"clubber\"...") #=> "\"I'm not\\na \\\"clubber\\\"...\""
-    #   DumpFilter.evaluate("I'm not\na \"clubber\"...") #== '"I\'m not\na \"clubber\"..."'
-    #   DumpFilter.evaluate('I\'m not\na "clubber"...')  #=> "\"I'm not\\\\na \\\"clubber\\\"...\""
-    #   DumpFilter.evaluate('I\'m not\na "clubber"...')  #== '"I\'m not\\\na \"clubber\"..."'
+    #   DumpFilter.call("I'm not\na \"clubber\"...") #=> "\"I'm not\\na \\\"clubber\\\"...\""
+    #   DumpFilter.call("I'm not\na \"clubber\"...") #== '"I\'m not\na \"clubber\"..."'
+    #   DumpFilter.call('I\'m not\na "clubber"...')  #=> "\"I'm not\\\\na \\\"clubber\\\"...\""
+    #   DumpFilter.call('I\'m not\na "clubber"...')  #== '"I\'m not\\\na \"clubber\"..."'
     #
     # @example Using as ActiveRecord::Base normalizer
     #   normalize :attribute_a, :with => :dump
@@ -25,7 +25,7 @@ module Normatron
       #
       # @param input [String] The String to be filtered
       # @return [String] A new dumpped String
-      def self.evaluate(input)
+      def self.call(input)
         input.kind_of?(String) ? input.dump : input
       end
     end

data/lib/normatron/filters/keep_filter.rb

@@ -84,11 +84,11 @@ module Normatron
     # Thai, Tibetan, Tifinagh, Ugaritic, Vai, and Yi.
     # 
     # @example Out of box
-    #   KeepFilter.evaluate("Doom 3", :L)      #=> "Doom"    keep only letters
-    #   KeepFilter.evaluate("Doom 3", :N)      #=> "3"       keep only numbers
-    #   KeepFilter.evaluate("Doom 3", :L, :N)  #=> "Doom3"   keep only letters and numbers
-    #   KeepFilter.evaluate("Doom 3", :Lu, :N) #=> "D3"      keep only uppercased letters or numbers
-    #   KeepFilter.evaluate("Doom ˩", :Latin)  #=> "Doom"    keep only latin characters
+    #   KeepFilter.call("Doom 3", :L)      #=> "Doom"    keep only letters
+    #   KeepFilter.call("Doom 3", :N)      #=> "3"       keep only numbers
+    #   KeepFilter.call("Doom 3", :L, :N)  #=> "Doom3"   keep only letters and numbers
+    #   KeepFilter.call("Doom 3", :Lu, :N) #=> "D3"      keep only uppercased letters or numbers
+    #   KeepFilter.call("Doom ˩", :Latin)  #=> "Doom"    keep only latin characters
     #
     # @example Using as ActiveRecord::Base normalizer
     #   normalize :attribute_a, :with => [[:keep, :Lu]]
@@ -109,7 +109,7 @@ module Normatron
       # @param input      [String]    The String to be filtered
       # @param properties [[Symbol]*] Symbols equivalent to Regexp property for @\\p{}@ construct
       # @return [String] A new clean String
-      def self.evaluate(input, *properties)
+      def self.call(input, *properties)
         input.kind_of?(String) ? evaluate_regexp(input, :keep, properties) : input
       end
     end

data/lib/normatron/filters/remove_filter.rb

@@ -9,11 +9,11 @@ module Normatron
     # For additional informations see Normatron::Filter::ClassMethods#keep documentation.
     # 
     # @example Out of box
-    #   RemoveFilter.evaluate("Quake 3", :L)      #=> " 3"        remove only letters
-    #   RemoveFilter.evaluate("Quake 3", :N)      #=> "Quake "    remove only numbers
-    #   RemoveFilter.evaluate("Quake 3", :L, :N)  #=> " "         remove only letters or numbers
-    #   RemoveFilter.evaluate("Quake 3", :Lu, :N) #=> "uake "     remove only uppercased letters or numbers
-    #   RemoveFilter.evaluate("Quake ˩", :Latin)  #=> " ˩"        remove only latin characters
+    #   RemoveFilter.call("Quake 3", :L)      #=> " 3"        remove only letters
+    #   RemoveFilter.call("Quake 3", :N)      #=> "Quake "    remove only numbers
+    #   RemoveFilter.call("Quake 3", :L, :N)  #=> " "         remove only letters or numbers
+    #   RemoveFilter.call("Quake 3", :Lu, :N) #=> "uake "     remove only uppercased letters or numbers
+    #   RemoveFilter.call("Quake ˩", :Latin)  #=> " ˩"        remove only latin characters
     #
     # @example Using as ActiveRecord::Base normalizer
     #   normalize :attribute_a, :with => [[:remove, :Lu]]
@@ -34,7 +34,7 @@ module Normatron
       # @param input      [String]    The String to be filtered
       # @param properties [[Symbol]*] Symbols equivalent to Regexp property for @\\p{}@ construct
       # @return [String] A new clean String
-      def self.evaluate(input, *properties)
+      def self.call(input, *properties)
         input.kind_of?(String) ? evaluate_regexp(input, :remove, properties) : input
       end
     end

data/lib/normatron/filters/squeeze_filter.rb

@@ -7,9 +7,9 @@ module Normatron
     # If no option are given, all runs of identical characters are replaced by a single character.
     # 
     # @example Out of box
-    #   SqueezeFilter.evaluate("yellow    moon")             #=> "yelow mon"
-    #   SqueezeFilter.evaluate("  now   is  the", " ")       #=> " now is the"
-    #   SqueezeFilter.evaluate("putters shoot balls", "m-z") #=> "puters shot balls"
+    #   SqueezeFilter.call("yellow    moon")             #=> "yelow mon"
+    #   SqueezeFilter.call("  now   is  the", " ")       #=> " now is the"
+    #   SqueezeFilter.call("putters shoot balls", "m-z") #=> "puters shot balls"
     #
     # @example Using as ActiveRecord::Base normalizer
     #   normalize :attribute_a, :with => [:custom_filter, :squeeze]
@@ -29,7 +29,7 @@ module Normatron
       # @param input   [String]    The String to be filtered
       # @param targets [[String]*] Characters to be affected
       # @return [String] A new squeezed String
-      def self.evaluate(input, *targets)
+      def self.call(input, *targets)
         return input unless input.kind_of?(String)
         targets.any? ? input.squeeze(targets.last) : input.squeeze
       end

data/lib/normatron/filters/squish_filter.rb

@@ -7,10 +7,10 @@ module Normatron
     # Strip input, remove line-breaks and multiple spaces.
     # 
     # @example Out of box
-    #   SquishFilter.evaluate("   the simpsons   ") #=> "the simpsons"
-    #   SquishFilter.evaluate("family      guy")    #=> "family guy"
-    #   SquishFilter.evaluate("the \n simpsons")    #=> "the simpsons"
-    #   SquishFilter.evaluate("the\nsimpsons")      #=> "the simpsons"
+    #   SquishFilter.call("   the simpsons   ") #=> "the simpsons"
+    #   SquishFilter.call("family      guy")    #=> "family guy"
+    #   SquishFilter.call("the \n simpsons")    #=> "the simpsons"
+    #   SquishFilter.call("the\nsimpsons")      #=> "the simpsons"
     #
     # @example Using as ActiveRecord::Base normalizer
     #   normalize :attribute, :with => [:custom_filter, :squish]
@@ -27,7 +27,7 @@ module Normatron
       #
       # @param input [String] The String to be filtered
       # @return [String] A new squished String
-      def self.evaluate(input)
+      def self.call(input)
         input.kind_of?(String) ? input.squish : input
       end
     end

data/lib/normatron/filters/strip_filter.rb

@@ -7,10 +7,10 @@ module Normatron
     # Removes traling and leading spaces.
     # 
     # @example Out of box
-    #   StripFilter.evaluate("   copy   ")      #=> "copy"
-    #   StripFilter.evaluate("   copy   ", :L)  #=> "copy   "
-    #   StripFilter.evaluate("   copy   ", :R)  #=> "   copy"
-    #   StripFilter.evaluate("   copy   ", :LR) #=> "copy"
+    #   StripFilter.call("   copy   ")      #=> "copy"
+    #   StripFilter.call("   copy   ", :L)  #=> "copy   "
+    #   StripFilter.call("   copy   ", :R)  #=> "   copy"
+    #   StripFilter.call("   copy   ", :LR) #=> "copy"
     #
     # @example Using as ActiveRecord::Base normalizer
     #   normalize :attribute_a, :with => :strip
@@ -33,7 +33,7 @@ module Normatron
       # @param input [String] The String to be filtered
       # @param edges [Symbol] @:L@ to strip trailing spaces, @:R@ for leading spaces or @:LR@ for both
       # @return [String] A new stripped String
-      def self.evaluate(input, edges=:LR)
+      def self.call(input, edges=:LR)
         return input unless input.kind_of?(String)
         
         regex_string = 

data/lib/normatron/filters/swapcase_filter.rb

@@ -7,7 +7,7 @@ module Normatron
     # Replaces uppercased characters by lowercased and vice versa.
     # 
     # @example Out of box
-    #   SwapcaseFilter.evaluate("As you Wish!") #=> "aS YOU wISH!"
+    #   SwapcaseFilter.call("As you Wish!") #=> "aS YOU wISH!"
     #
     # @example Using as ActiveRecord::Base normalizer
     #   normalize :attribute_a, :with => :swapcase
@@ -27,7 +27,7 @@ module Normatron
       #
       # @param input [String] The String to be filtered
       # @return [String] A new swapcased String
-      def self.evaluate(input)
+      def self.call(input)
         return input unless input.kind_of?(String)
         input.gsub(/([\p{Ll}])|(\p{Lu})|([^\p{Ll}\p{Lu}])/u) { $3 || ($2 ? mb_send(:downcase, $2) : mb_send(:upcase, $1)) }
       end

data/lib/normatron/filters/titleize_filter.rb

@@ -7,7 +7,7 @@ module Normatron
     # Capitalizes the first character of each word.
     # 
     # @example Out of box
-    #   TitleizeFilter.evaluate("at your will!") #=> "At Your Will!"
+    #   TitleizeFilter.call("at your will!") #=> "At Your Will!"
     #
     # @example Using as ActiveRecord::Base normalizer
     #   normalize :attribute_a, :with => :titleize
@@ -27,7 +27,7 @@ module Normatron
       #
       # @param input [String] The String to be filtered
       # @return [String] A new titleized String
-      def self.evaluate(input)
+      def self.call(input)
         input.kind_of?(String) ? mb_send(:titleize, input) : input
       end
     end

data/lib/normatron/filters/underscore_filter.rb

@@ -14,7 +14,7 @@ module Normatron
     #   "SSLError".underscore.camelize # => "SslError"
     # 
     # @example Out of box
-    #   UnderscoreFilter.evaluate("ActiveRecord::Errors") #=> "active_record/errors"
+    #   UnderscoreFilter.call("ActiveRecord::Errors") #=> "active_record/errors"
     #
     # @example Using as ActiveRecord::Base normalizer
     #   normalize :attribute_a, :with => :underscore
@@ -36,7 +36,7 @@ module Normatron
       #
       # @param input [String] The String to be filtered
       # @return [String] A new underscored String
-      def self.evaluate(input)
+      def self.call(input)
         return input unless input.kind_of?(String)
 
         string = input.gsub(/::/, '/')

data/lib/normatron/filters/upcase_filter.rb

@@ -7,7 +7,7 @@ module Normatron
     # Uppercase all characters.
     # 
     # @example Out of box
-    #   UpcaseFilter.evaluate("borderlands") #=> "BORDERLANDS"
+    #   UpcaseFilter.call("borderlands") #=> "BORDERLANDS"
     #
     # @example Using as ActiveRecord::Base normalizer
     #   normalize :attribute_a, :with => :upcase
@@ -27,7 +27,7 @@ module Normatron
       #
       # @param input [String] The String to be filtered
       # @return [String] A new uppercased String
-      def self.evaluate(input)
+      def self.call(input)
         input.kind_of?(String) ? mb_send(:upcase, input) : input
       end
     end

data/lib/normatron/version.rb

@@ -1,3 +1,3 @@
 module Normatron
-  VERSION = "0.3.3"
+  VERSION = "0.3.4"
 end

data/spec/support/matchers/character_cleaner_matcher.rb

@@ -23,7 +23,7 @@ module FilterMatchers
     def matches?(subject)
       @subject = subject
       @expected = @options[:input].gsub(regexp, '')
-      @got = @subject.evaluate(@options[:input], @options[:properties])
+      @got = @subject.call(@options[:input], @options[:properties])
       @failure_reason = failure_reason
       @failure_reason.nil?
     end

data/spec/support/matchers/evaluate_matcher.rb

@@ -62,9 +62,9 @@ module FilterMatchers
 
     def get_evaluation
       if @args.nil?
-        @filter.evaluate(@input)
+        @filter.call(@input)
       else
-        @filter.evaluate(@input, *@args)
+        @filter.call(@input, *@args)
       end
     end
 

data/spec/support/my_filters.rb

@@ -1,6 +1,6 @@
 module MyFilters
   module SmileFilter
-    def self.evaluate(value)
+    def self.call(value)
       value + " =]"
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: normatron
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
   prerelease: 
 platform: ruby
 authors: