normatron 0.2.0 → 0.2.1

data/README.textile

@@ -1,29 +1,28 @@
 h1. Normatron
 
-Normatron is an attribute normalizer for ActiveRecord objects.
-With it you can convert attributes to the desired format before saving them in the database.
+Normatron is an Ruby On Rails plugin that perform attribute normalizations for ActiveRecord objects.
+With it you can normalize attributes to the desired format before saving them in the database.
 This gem inhibits the work of having to override attributes or create a specific method to perform most of the normalizations.
 
 h2. Installation
 
 Let the bundler install the gem by adding the following into your application gemfile:
 
-<pre>gem 'normatron'</pre>
+pre. gem 'normatron'
 
 And then bundle it up:
 
-<pre>$ bundle install</pre>
+pre. $ bundle install
 
 Or install it by yourself:
 
-<pre>$ gem install normatron</pre>
+pre. $ gem install normatron
 
 h2. The problem
 
 Suppose you have a product model as the following:
 
-<pre>
-# ./db/migrate/20120101010000_create_products.rb
+pre. # ./db/migrate/20120101010000_create_products.rb
 class CreateProducts < ActiveRecord::Migration
   def change
     create_table :products do |t|
@@ -33,88 +32,63 @@ class CreateProducts < ActiveRecord::Migration
   end
 end
 
-# ./app/models/products.rb
+pre. # ./app/models/products.rb
 class Product < ActiveRecord::Base
   attr_accessible :name, :price
 end
-</pre>
 
 And we want the _name_ attribute be uppercased before saving it into the database.
 The most usual approach to do this includes:
 
 * Override the _name_ setter and convert the value to an uppercased string.
-* Use the _before_validation_ callback to run a method or block doing the task.
+* Use the "_before_validation_":http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html callback to run a method or block doing the task.
 
 Both ways are ilenegant, boring, error prone and very expensive.
-What led me to make this gem and offer a third way to solve the problem:
+What led me to make this gem and offer a third way to solve this issue:
 
 h2. Usage
 
-Normatron uses ":squish":http://rubydoc.info/gems/normatron/Normatron/Filters#squish-class_method and ":blank":http://rubydoc.info/gems/normatron/Normatron/Filters#blank-class_method as default filters.
-These filters are applied to all attributes in *normalize* function, since no options is given.
+Normatron uses "_:squish_":http://rubydoc.info/gems/normatron/Normatron/Filters#squish-class_method and "_:blank_":http://rubydoc.info/gems/normatron/Normatron/Filters#blank-class_method as default filters.
+These filters are applied to all attributes in @normalize@ function, since no options is given.
 
-<pre>
-# ./app/models/products.rb
+pre. # ./app/models/products.rb
 class Product < ActiveRecord::Base
   attr_accessible :name, :price
   normalize :name
 end
 
-$ rails console
-> p1 = Product.create name: "  memory   card    "
-> p1
+pre.  $ rails console
+ > p1 = Product.create name: "  memory   card    "
 => #<Product id: nil, name: "memory card", price: nil>
-> p2 = Product.create name: "    "
-> p2
+ > p2 = Product.create name: "    "
 => #<Product id: nil, name: nil, price: nil>
-</pre>
 
 h3. The _normalize_attributes_ method
 
-All filters are automatically applied in the "before_validation":http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html callback.
-So, the changes occur when you call any method that validates the model.
+Methods like "create":http://api.rubyonrails.org/classes/ActiveRecord/Persistence/ClassMethods.html#method-i-create, "valid?":http://api.rubyonrails.org/classes/ActiveRecord/Validations.html#method-i-valid-3F or "save":http://api.rubyonrails.org/classes/ActiveRecord/Validations.html#method-i-valid-3F always call the _normalize_attributes_ method, thought "before_validation":http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html callback.
+This is the method that invokes all filters to their attributes. So you can perform the normalizations without necessarily having to perform the model validations.
 
-<pre>
-$ rails console
-> p = Product.create name: "      "
-> p.name
-=> nil
-> p = Product.new name: "   keyboard     \n        "
-> p.valid?
-> p.name
-=> "keyboard"
-> p = Product.new name: "\n\nblu    ray\n\n"
-> p.save
-> p.name
-=> "blu ray"
-</pre>
-
-We can call the *normalize_attributes* method to perform the normalization without do the validations.
-
-<pre>
-> p = Product.new name: "  hard    drive"
-> p.normalize_attributes
-> p.name
-=> "hard drive"
-</pre>
+pre.  $ rails console
+ > p = Product.new name: "  hard    drive"
+=> #<Product id: nil, name: "  hard    drive", price: nil>
+ > p.normalize_attributes
+ > p
+=> #<Product id: nil, name: "hard drive", price: nil>
 
 h3. The _normalize_options_ method
 
-To read the normalization filters set for a model, just call the *normalize_options* method.
+To read the normalization filters set for a model, just call the @normalize_options@ method.
 
-<pre>
-$ rails console
-> Product.normalize_options
+pre.  $ rails console
+ > Product.normalize_options
 => { name: { :squish => [], :blank => [] } }
-</pre>
 
-This method returns a Hash, where the keys are the attribute names and values ​​are another Hash with filter options.
-In Hash with filter options, keys represent the filter names and the values ​​are Arrays with the arguments that are passed to the methods of filtering.
-The following example is a data structure returned by the _normalize_options_ method.
+This method returns a Hash, where the keys are the attribute names and values are another Hash with filter options.
+In the filter options Hash, keys represent the filter names and the values are Arrays containing arguments to be passed to filter methods.
+The following example is a data structure returned by the @normalize_options@ method:
 
-<pre>
-$ rails console
-> MyModel.normalize_options
+pre.  $ rails console
+ > MyModel.normalize_options
 => { :attribute_a => { :filter_a => [] },
      :attribute_b => { :filter_a => [],
                        :filter_b => [arg_a, arg_b] },
@@ -124,76 +98,65 @@ $ rails console
      :attribute_d => { :filter_a => [],
                        :filter_c => [arg],
                        :filter_d => [arg_a, arg_b, arg_c, arg_d] } }
-</pre>
 
 h3. The _:with_ option
 
-The _:with_ option allows to bind filters to one attribute or more.
+The @:with@ option allows to bind filters to one or more attribute.
 
-<pre>
-class Product < ActiveRecord::Base
+pre. class Product < ActiveRecord::Base
   normalize :name, :with => :upcase
 end
 
-$ rails console
-> Product.normalize_options
+pre.  $ rails console
+ > Product.normalize_options
 => { :name => { :upcase => [] } }
-</pre>
 
-The filters passed throught _:with_ option will not stack with default filters.
-When _normalize_ method is used multiple times for the same attribute, it will stack the filter bindings.
+The filters passed throught @:with@ option will not stack with default filters.
+When @normalize@ method is used multiple times for the same attribute, it will stack the filter bindings.
 
-<pre>
-class Product < ActiveRecord::Base
+pre. class Product < ActiveRecord::Base
   normalize :name
   normalize :name, :with => :upcase
 end
 
-$ rails console
-> Product.normalize_options
+pre.  $ rails console
+ > Product.normalize_options
 => { :name => { :squish => [],
                 :blank  => [],
                 :upcase => [] } }
-</pre>
 
 The same result can be obtained using:
 
-<pre>normalize :name, :with => [:squish, :blank, :upcase]</pre>
+pre. normalize :name, :with => [:squish, :blank, :upcase]
 
 Some filters may use arguments to perferm normalizations.
 There are two approaches to deal with filter arguments in Normatron:
 
-a) Using a Hash where the key is the filter name and the value is the filter arguments as an Array.
+a) Using a Hash where the key is the filter name and the value is an arguments Array.
 
-<pre>
-class Product < ActiveRecord::Base
+pre. class Product < ActiveRecord::Base
   normalize :name,        :with => [ { :keep => [:Latin], :remove => [:Nd, :Zs] } ]
   normalize :description, :with => :squeeze
   normalize :brand,       :with => [ { :squeeze => ["a-z"] }, { :keep => [:Word] } ]
 end
-</pre>
 
 b) Using an Array where the first element if the attribute name and rest is the filter arguments.
 
-<pre>
-class Product < ActiveRecord::Base
+pre. class Product < ActiveRecord::Base
   normalize :name,        :with => [ [:keep, :Latin], [:remove, :Nd, :Zs] ]
   normalize :description, :with => :squeeze
   normalize :brand,       :with => [ [:squeeze, "a-z"], [:keep, :Word] ]
 end
-</pre>
 
 Both ways will produce the same result:
 
-<pre>
-$ rails console
-> Product.normalize_options
+pre.  $ rails console
+ > Product.normalize_options
 => { :name        => { :keep    => [:Latin],
                        :remove  => [:Nd, :Zs] },
      :description => { :squeeze => [] },
      :brand       => { :squeeze => ["a-z"],
                        :keep    => [:Word] } }
-</pre>
 
 h3. Using instance method as filter
 
@@ -204,7 +167,8 @@ If you need to use aditional arguments or varargs, just add them after the first
 <pre>
 # ./app/models/client.rb
 class Client < ActiveRecord::Base
-  normalize :phone, :with => [:custom_a, [:custom_b, :a, :b], { :custom_c => [:a, :b, :c] }]
+  normalize :phone,  :with => [:custom_a, [:custom_b, :a, :b], {:custom_c => [:a, :b, :c]}]
+  normalize :mobile, :with => [:custom_a, {:custom_b => [:a, :b]}, [:custom_c, :a, :b, :c]]
 
   def custom_a(value)
     # ...
@@ -222,18 +186,21 @@ end
 
 h2. Filters
 
-Information about native filters and how to use them can be found in:
-
-* "Normatron::Filters Rubydoc (Normatron::Filters Rubydoc)":http://rubydoc.info/gems/normatron/Normatron/Filters
-* "Normatron::Filters Source (Normatron::Filters Source)":https://github.com/fernandors87/normatron/blob/master/lib/normatron/filters.rb
+Information about native filters and how to use them can be found in "Normatron::Filters(Normatron::Filters Rubydoc)":http://rubydoc.info/gems/normatron/Normatron/Filters. All methods have a short description of what they do and some examples of how to use them.
 
 h1. Contributing
 
-* Fork it, add your new features or bug fixes, make your tests and commit.
-* Report any bug or unexpected behavior.
-* Share with your friends, forums, communities, job, etc...
-* Send me your feedback.
-* Offer me a job or pay me a beer. =]
+There are several ways to make this gem even better:
+
+* Forking this project
+* Adding new features or bug fixes
+* Making tests
+* Commiting your changes
+* Reporting any bug or unexpected behavior
+* Suggesting any improvement
+* Sharing with your friends, forums, communities, job, etc...
+* Helping users with difficulty using this gem
+* Paying me a beer =]
 
 h1. Credits
 

data/lib/normatron.rb

@@ -2,7 +2,7 @@ require "normatron/configuration"
 require "normatron/extensions/active_record"
 
 module Normatron
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 
   class << self
     def configuration

data/lib/normatron/configuration.rb

@@ -20,7 +20,7 @@ module Normatron
     end
 
     def initialize
-      @default_filters = {squish: [], blank: []}
+      @default_filters = { squish: [], blank: [] }
     end
 
     def default_filters

data/lib/normatron/filters.rb

@@ -2,11 +2,14 @@
 
 require 'active_support/multibyte/chars'
 require 'active_support/core_ext/string'
+require 'active_support/inflector/inflections'
 
 module Normatron
   module Filters
+    extend self
+
     ##
-    # Converts a blank string on a nil object.
+    # Returns a <tt>Nil</tt> object for a blank string or the string itself otherwise.
     # 
     # @example
     #   blank("")            #=> nil
@@ -16,34 +19,111 @@ module Normatron
     #   blank("It's blank?") #=> "It's blank?"
     #   blank(123)           #=> 123
     #
-    #   # For normalizations
-    #   normalize :attribute, :with => [:custom_filter, :blank]
+    #   # ActiveRecord normalizer usage
+    #   normalize :attribute_a, :with => :blank
+    #   normalize :attribute_b, :with => [:custom_filter, :blank]
     # @param [String] value A character sequence
     # @return [String, Nil] The object itself or nil
     # @see http://api.rubyonrails.org/classes/String.html#method-i-blank-3F String#blank?
-    def self.blank(value)
+    def blank(value)
       return value unless string?(value) && value.to_s.blank?
       nil
     end
 
     ##
-    # Converts the first character to uppercase and others to lowercase.
+    # Converts strings to UpperCamelCase.
+    # If the argument to camelize is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
+    # camelize will also convert <tt>'/'</tt> to <tt>'::'</tt> which is useful for converting paths to namespaces.
+    # 
+    # @example
+    #   camelize("active_record/errors")         #=> "ActiveRecord::Errors"
+    #   camelize("active_record/errors", :upper) #=> "ActiveRecord::Errors"
+    #   camelize("active_record/errors", :lower) #=> "activeRecord::Errors"
+    #   camelize(123)                            #=> 123
+    #
+    #   # ActiveRecord normalizer usage
+    #   normalize :attribute_a, :with => :camelize
+    #   normalize :attribute_b, :with => [:custom_filter, :camelize]
+    #   normalize :attribute_c, :with => [[:camelize, :lower]]
+    #   normalize :attribute_d, :with => [{:camelize => :lower}]
+    #   normalize :attribute_e, :with => [:custom_filter, [:camelize, :lower]]
+    #   normalize :attribute_f, :with => [:custom_filter, {:camelize => :lower}]
+    # @param [String] value A character sequence
+    # @param [Symbol] first_letter_case <tt>:lower</tt> for lowerCamelCase or <tt>:upper</tt> for UpperCamelCase
+    # @return [String, Object] The camelized String or the object itself
+    def camelize(value, first_letter_case = :upper)
+      case value
+      when String
+        string = value
+      when ActiveSupport::Multibyte::Chars
+        string = value.to_s
+      else
+        return value
+      end
+
+      inflections = ActiveSupport::Inflector::Inflections.instance
+      if first_letter_case == :upper
+        string = string.sub(/^[\p{L}\d]*/u) { inflections.acronyms[$&] || capitalize($&) }
+      elsif first_letter_case == :lower
+        string = string.sub(/^(?:#{inflections.acronym_regex}(?=\b|[\p{L}_])|\p{Word}*_)/u) { downcase($&) }
+      else
+        raise "Use options :upper or :lower for Normatron::Filters#camelize"
+      end
+      string.gsub!(/(?:_|(\/))([\p{L}\d]*)/iu) { "#{$1}#{inflections.acronyms[$2] || capitalize($2)}" }.gsub!('/', '::')
+
+      (value.is_a?(String) && string) || string.mb_chars
+    end
+
+    ##
+    # Makes the first character uppercase and lowercase others.
     # 
     # @example
-    #   capitalize("walter white") #=> "Walter white"
+    #   capitalize("jESSE PINK")   #=> "Jesse pink"
     #   capitalize("wALTER WHITE") #=> "Walter white"
+    #   capitalize(" mr. Fring")   #=> " mr. fring"
     #   capitalize(123)            #=> 123
     #
-    #   # For normalizations
-    #   normalize :attribute, :with => [:custom_filter, :capitalize]
+    #   # ActiveRecord normalizer usage
+    #   normalize :attribute_a, :with => :capitalize
+    #   normalize :attribute_b, :with => [:custom_filter, :capitalize]
     # @param [String] value A character sequence
     # @return [String, Object] The capitalized String or the object itself
     # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-capitalize String#capitalize
     # @see http://api.rubyonrails.org/classes/ActiveSupport/Multibyte/Chars.html#method-i-capitalize ActiveSupport::Multibyte::Chars#capitalize
-    def self.capitalize(value)
+    def capitalize(value)
       (string?(value) && eval_send(:capitalize, value)) || value
     end
 
+    ##
+    # Remove the given record separator from the end of the string (If present).
+    # If <tt>$/</tt> has not been changed from the default Ruby record separator,
+    # then chomp also removes carriage return characters (that is it will remove <tt>\n</tt>, <tt>\r</tt>, and <tt>\r\n</tt>).
+    # 
+    # @example
+    #   chomp("Bon \n Scott\n")            #=> "Bon \n Scott"
+    #   chomp("Bon \n Scott\r")            #=> "Bon \n Scott"
+    #   chomp("Bon \n Scott\r\n")          #=> "Bon \n Scott"
+    #   chomp("Bon \n Scott\n\r")          #=> "Bon \n Scott\n"
+    #   chomp("Bon \n Scott", "t")         #=> "Bon \n Scot"
+    #   chomp("Bon \n Scott", "Scott")     #=> "Bon \n "
+    #   chomp("Bon \n Scott", " \n Scott") #=> "Bon"
+    #   chomp(100)                         #=> 100
+    #
+    #   # ActiveRecord normalizer usage
+    #   normalize :attribute_a, :with => :chomp
+    #   normalize :attribute_b, :with => [:custom_filter, :chomp]
+    #   normalize :attribute_c, :with => [[:chomp, "x"]]
+    #   normalize :attribute_d, :with => [{:chomp => "y"}]
+    #   normalize :attribute_e, :with => [:custom_filter, [:chomp, "z"]]
+    #   normalize :attribute_f, :with => [:custom_filter, {:chomp => "\t"}]
+    # @param [String] value A character sequence
+    # @param [String] separator A character sequence
+    # @return [String, Object] The chopped String or the object itself
+    # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-chomp String#chomp
+    def chomp(value, separator=$/)
+      (string?(value) && eval_send(:chomp, value, separator)) || value
+    end
+
     ##
     # Replaces all underscores with dashes.
     # 
@@ -52,32 +132,55 @@ module Normatron
     #   dasherize("_.·-'*'-·._")  #=> "-.·-'*'-·.-"
     #   dasherize(123)            #=> 123
     #
-    #   # For normalizations
-    #   normalize :attribute, :with => [:custom_filter, :dasherize]
+    #   # ActiveRecord normalizer usage
+    #   normalize :attribute_a, :with => :dasherize
+    #   normalize :attribute_b, :with => [:custom_filter, :dasherize]
     # @param [String] value A character sequence
     # @return [String, Object] The dasherized String or the object itself
     # @see http://api.rubyonrails.org/classes/String.html#method-i-dasherize String#dasherize
-    def self.dasherize(value)
+    def dasherize(value)
       (string?(value) && eval_send(:dasherize, value)) || value
     end
 
     ##
-    # Converts all characters to lowercase.
+    # Lowercase all characters.
     # 
     # @example
     #   downcase("VEGETA!!!") #=> "vegeta!!!"
     #   downcase(123)         #=> 123
     #
-    #   # For normalizations
-    #   normalize :attribute, :with => [:custom_filter, :downcase]
+    #   # ActiveRecord normalizer usage
+    #   normalize :attribute_a, :with => :downcase
+    #   normalize :attribute_b, :with => [:custom_filter, :downcase]
     # @param [String] value A character sequence
     # @return [String, Object] The lowercased String or the object itself
     # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-downcase String#downcase
     # @see http://api.rubyonrails.org/classes/ActiveSupport/Multibyte/Chars.html#method-i-downcase ActiveSupport::Multibyte::Chars#downcase
-    def self.downcase(value)
+    def downcase(value)
       (string?(value) && eval_send(:downcase, value)) || value
     end
 
+    ##
+    # Creates a literal string representation with all nonprinting characters
+    # replaced by <tt>\\n</tt> notation and all special characters escaped.
+    # 
+    # @example
+    #   dump("I'm not\na \"clubber\"...") #=> "\"I'm not\\na \\\"clubber\\\"...\""
+    #   dump("I'm not\na \"clubber\"...") #== '"I\'m not\na \"clubber\"..."'
+    #   dump('I\'m not\na "clubber"...')  #=> "\"I'm not\\\\na \\\"clubber\\\"...\""
+    #   dump('I\'m not\na "clubber"...')  #== '"I\'m not\\\na \"clubber\"..."'
+    #   dump(100)                         #=> 100
+    #
+    #   # ActiveRecord normalizer usage
+    #   normalize :attribute_a, :with => :dump
+    #   normalize :attribute_b, :with => [:custom_filter, :dump]
+    # @param [String] value A character sequence
+    # @return [String, Object] The dumpped String or the object itself
+    # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-dump String#dump
+    def dump(value)
+      (string?(value) && eval_send(:dump, value)) || value
+    end
+
     ##
     # Keep only the specified characters.
     # Details about the options can be found in the Regexp class documentation.
@@ -97,7 +200,7 @@ module Normatron
     # @param [[Symbol]*] args Array of Symbols equivalent to Regexp for \\p{} construct.
     # @return [String, Object] The clean character sequence or the object itself
     # @see http://www.ruby-doc.org/core-1.9.3/Regexp.html Regexp
-    def self.keep(value, *args)
+    def keep(value, *args)
       eval_regexp(value, true, args)
     end
 
@@ -112,7 +215,7 @@ module Normatron
     # @param [String] value A character sequence
     # @return [String, Object] The character sequence without trailing spaces or the object itself
     # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-lstrip String#lstrip
-    def self.lstrip(value)
+    def lstrip(value)
       (string?(value) && eval_strip(value, true, false)) || value
     end
 
@@ -135,7 +238,7 @@ module Normatron
     # @param [[Symbol]*] args Array of Symbols equivalent to Regexp for \\p{} construct.
     # @return [String, Object] The clean character sequence or the object itself
     # @see http://www.ruby-doc.org/core-1.9.3/Regexp.html Regexp
-    def self.remove(value, *args)
+    def remove(value, *args)
       eval_regexp(value, false, args)
     end
 
@@ -150,7 +253,7 @@ module Normatron
     # @param [String] value A character sequence
     # @return [String, Object] The character sequence without leading spaces or the object itself
     # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-rstrip String#rstrip
-    def self.rstrip(value)
+    def rstrip(value)
       (string?(value) && eval_strip(value, false, true)) || value
     end
 
@@ -171,7 +274,7 @@ module Normatron
     # @param [[String]*] args Chars to be affected
     # @return [String, Object] The clean character sequence or the object itself
     # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-squeeze String#squeeze
-    def self.squeeze(value, *args)
+    def squeeze(value, *args)
       return value unless string?(value)
       (args.any? && value.squeeze(args.first)) || value.squeeze
     end
@@ -188,7 +291,7 @@ module Normatron
     # @return [String, Object] The clean character sequence or the object itself
     #
     # @see http://api.rubyonrails.org/classes/String.html#method-i-squish String#squish
-    def self.squish(value)
+    def squish(value)
       (string?(value) && value.squish) || value
     end
 
@@ -202,10 +305,27 @@ module Normatron
     #   normalize :attribute, :with => [:custom_filter, :strip]
     # @param [String] value A character sequence
     # @return [String, Object] The stripped character sequence or the object itself
-    def self.strip(value)
+    def strip(value)
       (string?(value) && eval_strip(value, true, true)) || value
     end
 
+    ##
+    # Replaces uppercased characters by lowercased and vice versa.
+    # 
+    # @example
+    #   swapcase("AiNn Kmo éH BOM ser v1d4 l0k4") #=> "aInN kMO Éh bom SER V1D4 L0K4"
+    #   swapcase(100)                             #=> 100
+    #
+    #   # ActiveRecord normalizer usage
+    #   normalize :attribute_a, :with => :swapcase
+    #   normalize :attribute_b, :with => [:custom_filter, :swapcase]
+    # @param [String] value A character sequence
+    # @return [String, Object] The String with case swapped or the object itself
+    def swapcase(value)
+      return value unless string?(value)
+      value.gsub(/./) { |c| (/\p{Lu}/.match(c) && downcase(c) || (/\p{Ll}/.match(c) && upcase(c))) || c }
+    end
+
     ##
     # Converts all characters to uppercase.
     # 
@@ -219,32 +339,36 @@ module Normatron
     # @return [String, Object] The lowercased String or the object itself
     # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-upcase String#upcase
     # @see http://api.rubyonrails.org/classes/ActiveSupport/Multibyte/Chars.html#method-i-upcase ActiveSupport::Multibyte::Chars#upcase
-    def self.upcase(value)
+    def upcase(value)
       (string?(value) && eval_send(:upcase, value)) || value
     end
 
     protected
 
-    def self.eval_regexp(value, keep, *args)
+    def eval_regexp(value, keep, *args)
       return value unless string?(value)
       
       options = args.flatten.compact.uniq
 
-      regex = options.map{|s| "\\p{#{s.to_s}}"} * ""
+      regex = options.map{ |s| "\\p{#{s.to_s}}" } * ""
       regex.prepend('^') if keep
       regex = eval "/[#{regex}]/u"
 
       value.gsub(regex, "")
     end
 
-    def self.eval_send(method, value)
+    def eval_send(method, value, option=nil)
       type = value.class
       value = value.mb_chars if type == String
-      value = value.send(method)
+      if option
+        value = value.send(method, option)
+      else
+        value = value.send(method)
+      end
       (type == String && value.to_s) || value
     end
 
-    def self.eval_strip(value, start, ending)
+    def eval_strip(value, start, ending)
       regex = []
       regex << '\A\p{Zs}*' if start
       regex << '\p{Zs}*\z' if ending
@@ -253,7 +377,7 @@ module Normatron
       value.gsub(regex, '')
     end
 
-    def self.string?(value)
+    def string?(value)
       value.is_a?(ActiveSupport::Multibyte::Chars) || value.is_a?(String)
     end
   end

data/spec/filters_spec.rb

@@ -7,15 +7,106 @@ describe Normatron::Filters do
   subject { described_class }
   let(:mb_chars) { ActiveSupport::Multibyte::Chars }
 
+  #
+  # BLANK
+  ###################################################################################################################
   describe "::blank" do
     it { subject.blank("    .      "         ).should eq "    .      " }
+    it { subject.blank("    .      ".mb_chars).should eq "    .      ".mb_chars }
+    
+    it { subject.blank("    .      "         ).should be_a String }
     it { subject.blank("           "         ).should be_nil }
     it { subject.blank("\n \t \r \f"         ).should be_nil }
-    it { subject.blank("    .      "         ).should be_a String }
+
     it { subject.blank("    .      ".mb_chars).should be_a mb_chars }
+    it { subject.blank("           ".mb_chars).should be_nil }
+    it { subject.blank("\n \t \r \f".mb_chars).should be_nil }
+
     it { subject.blank(100                   ).should eq 100 }
     it { subject.blank(nil                   ).should be_nil }
   end
+  
+  #
+  # CAMELIZE
+  ###################################################################################################################
+  describe "::camelize" do
+    it { subject.camelize("active_record/errors"                 ).should eq "ActiveRecord::Errors" }
+    it { subject.camelize("áctivé_record/érrórs"                 ).should eq "ÁctivéRecord::Érrórs" }
+    it { subject.camelize("ActivE_record/ErrOrs"                 ).should eq "ActiveRecord::Errors" }
+    it { subject.camelize("ÁctivÉ_record/ÉrrÓrs"                 ).should eq "ÁctivéRecord::Érrórs" }
+    it { subject.camelize("active_record/errors", :upper         ).should eq "ActiveRecord::Errors" }
+    it { subject.camelize("áctivé_record/érrórs", :upper         ).should eq "ÁctivéRecord::Érrórs" }
+    it { subject.camelize("ActivE_record/ErrOrs", :upper         ).should eq "ActiveRecord::Errors" }
+    it { subject.camelize("ÁctivÉ_record/ÉrrÓrs", :upper         ).should eq "ÁctivéRecord::Érrórs" }
+    it { subject.camelize("active_record/errors", :lower         ).should eq "activeRecord::Errors" }
+    it { subject.camelize("áctivé_record/érrórs", :lower         ).should eq "áctivéRecord::Érrórs" }
+    it { subject.camelize("ActivE_record/ErrOrs", :lower         ).should eq "activeRecord::Errors" }
+    it { subject.camelize("ÁctivÉ_record/ÉrrÓrs", :lower         ).should eq "áctivéRecord::Érrórs" }
+
+    it { subject.camelize("active_record/errors".mb_chars        ).should eq "ActiveRecord::Errors".mb_chars }
+    it { subject.camelize("áctivé_record/érrórs".mb_chars        ).should eq "ÁctivéRecord::Érrórs".mb_chars }
+    it { subject.camelize("ActivE_record/ErrOrs".mb_chars        ).should eq "ActiveRecord::Errors".mb_chars }
+    it { subject.camelize("ÁctivÉ_record/ÉrrÓrs".mb_chars        ).should eq "ÁctivéRecord::Érrórs".mb_chars }
+    it { subject.camelize("active_record/errors".mb_chars, :upper).should eq "ActiveRecord::Errors".mb_chars }
+    it { subject.camelize("áctivé_record/érrórs".mb_chars, :upper).should eq "ÁctivéRecord::Érrórs".mb_chars }
+    it { subject.camelize("ActivE_record/ErrOrs".mb_chars, :upper).should eq "ActiveRecord::Errors".mb_chars }
+    it { subject.camelize("ÁctivÉ_record/ÉrrÓrs".mb_chars, :upper).should eq "ÁctivéRecord::Érrórs".mb_chars }
+    it { subject.camelize("active_record/errors".mb_chars, :lower).should eq "activeRecord::Errors".mb_chars }
+    it { subject.camelize("áctivé_record/érrórs".mb_chars, :lower).should eq "áctivéRecord::Érrórs".mb_chars }
+    it { subject.camelize("ActivE_record/ErrOrs".mb_chars, :lower).should eq "activeRecord::Errors".mb_chars }
+    it { subject.camelize("ÁctivÉ_record/ÉrrÓrs".mb_chars, :lower).should eq "áctivéRecord::Érrórs".mb_chars }
+
+    it { subject.camelize("active_record/errors"                 ).should be_a String }
+    it { subject.camelize("áctivé_record/érrórs"                 ).should be_a String }
+    it { subject.camelize("ActivE_record/ErrOrs"                 ).should be_a String }
+    it { subject.camelize("ÁctivÉ_record/ÉrrÓrs"                 ).should be_a String }
+    it { subject.camelize("active_record/errors", :upper         ).should be_a String }
+    it { subject.camelize("áctivé_record/érrórs", :upper         ).should be_a String }
+    it { subject.camelize("ActivE_record/ErrOrs", :upper         ).should be_a String }
+    it { subject.camelize("ÁctivÉ_record/ÉrrÓrs", :upper         ).should be_a String }
+    it { subject.camelize("active_record/errors", :lower         ).should be_a String }
+    it { subject.camelize("áctivé_record/érrórs", :lower         ).should be_a String }
+    it { subject.camelize("ActivE_record/ErrOrs", :lower         ).should be_a String }
+    it { subject.camelize("ÁctivÉ_record/ÉrrÓrs", :lower         ).should be_a String }
+
+    it { subject.camelize("active_record/errors".mb_chars        ).should be_a mb_chars }
+    it { subject.camelize("áctivé_record/érrórs".mb_chars        ).should be_a mb_chars }
+    it { subject.camelize("ActivE_record/ErrOrs".mb_chars        ).should be_a mb_chars }
+    it { subject.camelize("ÁctivÉ_record/ÉrrÓrs".mb_chars        ).should be_a mb_chars }
+    it { subject.camelize("active_record/errors".mb_chars, :upper).should be_a mb_chars }
+    it { subject.camelize("áctivé_record/érrórs".mb_chars, :upper).should be_a mb_chars }
+    it { subject.camelize("ActivE_record/ErrOrs".mb_chars, :upper).should be_a mb_chars }
+    it { subject.camelize("ÁctivÉ_record/ÉrrÓrs".mb_chars, :upper).should be_a mb_chars }
+    it { subject.camelize("active_record/errors".mb_chars, :lower).should be_a mb_chars }
+    it { subject.camelize("áctivé_record/érrórs".mb_chars, :lower).should be_a mb_chars }
+    it { subject.camelize("ActivE_record/ErrOrs".mb_chars, :lower).should be_a mb_chars }
+    it { subject.camelize("ÁctivÉ_record/ÉrrÓrs".mb_chars, :lower).should be_a mb_chars }
+
+    it { subject.camelize(100                                    ).should eq 100 }
+    it { subject.camelize(100, :upper                            ).should eq 100 }
+    it { subject.camelize(100, :lower                            ).should eq 100 }
+    it { subject.camelize(nil                                    ).should be_nil }
+    it { subject.camelize(nil, :upper                            ).should be_nil }
+    it { subject.camelize(nil, :lower                            ).should be_nil }
+
+    it { expect { subject.camelize("ÁctivÉ_record/ÉrrÓrs", :other) }.to raise_error }
+
+    context "should affect acronyms" do
+      let(:inflections) { ActiveSupport::Inflector::Inflections.instance }
+
+      before(:all) do
+        inflections.acronym 'HTTP'
+        inflections.acronym 'SSL'
+      end
+
+      it { subject.camelize("http_address/ssl", :upper).should eq "HTTPAddress::SSL" }
+      it { subject.camelize("http_address/ssl", :lower).should eq "httpAddress::SSL" }
+
+      after(:all) do
+        inflections.acronyms = {}
+      end
+    end
+  end
 
   describe "::capitalize" do
     it { subject.capitalize("abcDEF GhI"         ).should eq "Abcdef ghi" }
@@ -27,6 +118,102 @@ describe Normatron::Filters do
     it { subject.capitalize(nil                  ).should be_nil }
   end
 
+  #
+  # CHOMP
+  ###################################################################################################################
+  describe "::chomp" do
+    it { subject.chomp("abcdef ghijkl"                             ).should eq "abcdef ghijkl" }
+    it { subject.chomp("abcdef ghij\n"                             ).should eq "abcdef ghij"   }
+    it { subject.chomp("abc\nd efghij"                             ).should eq "abc\nd efghij" }
+    it { subject.chomp("abc\nd ef\n\r"                             ).should eq "abc\nd ef\n"   }
+    it { subject.chomp("abc\nd ef\r\n"                             ).should eq "abc\nd ef"     }
+    it { subject.chomp("abcdef ghijkl", "jkl"                      ).should eq "abcdef ghi"    }
+    it { subject.chomp("abcdef ghij\n", "j\n"                      ).should eq "abcdef ghi"    }
+    it { subject.chomp("abc\nd efghij", " efghij"                  ).should eq "abc\nd"        }
+    it { subject.chomp("abc\nd ef\n\r", "\n\r"                     ).should eq "abc\nd ef"     }
+    it { subject.chomp("abc\nd ef\r\n", "\n"                       ).should eq "abc\nd ef"     }
+
+    it { subject.chomp("abcdef ghijkl"                             ).should eq "abcdef ghijkl" }
+    it { subject.chomp("abcdef ghij\n"                             ).should eq "abcdef ghij"   }
+    it { subject.chomp("abc\nd efghij"                             ).should eq "abc\nd efghij" }
+    it { subject.chomp("abc\nd ef\n\r"                             ).should eq "abc\nd ef\n"   }
+    it { subject.chomp("abc\nd ef\r\n"                             ).should eq "abc\nd ef"     }
+    it { subject.chomp("abcdef ghijkl", "jkl"    .mb_chars         ).should eq "abcdef ghi"    }
+    it { subject.chomp("abcdef ghij\n", "j\n"    .mb_chars         ).should eq "abcdef ghi"    }
+    it { subject.chomp("abc\nd efghij", " efghij".mb_chars         ).should eq "abc\nd"        }
+    it { subject.chomp("abc\nd ef\n\r", "\n\r"   .mb_chars         ).should eq "abc\nd ef"     }
+    it { subject.chomp("abc\nd ef\r\n", "\n"     .mb_chars         ).should eq "abc\nd ef"     }
+
+    it { subject.chomp("abcdef ghijkl".mb_chars                    ).should eq "abcdef ghijkl".mb_chars }
+    it { subject.chomp("abcdef ghij\n".mb_chars                    ).should eq "abcdef ghij"  .mb_chars }
+    it { subject.chomp("abc\nd efghij".mb_chars                    ).should eq "abc\nd efghij".mb_chars }
+    it { subject.chomp("abc\nd ef\n\r".mb_chars                    ).should eq "abc\nd ef\n"  .mb_chars }
+    it { subject.chomp("abc\nd ef\r\n".mb_chars                    ).should eq "abc\nd ef"    .mb_chars }
+    it { subject.chomp("abcdef ghijkl".mb_chars, "jkl"             ).should eq "abcdef ghi"   .mb_chars }
+    it { subject.chomp("abcdef ghij\n".mb_chars, "j\n"             ).should eq "abcdef ghi"   .mb_chars }
+    it { subject.chomp("abc\nd efghij".mb_chars, " efghij"         ).should eq "abc\nd"       .mb_chars }
+    it { subject.chomp("abc\nd ef\n\r".mb_chars, "\n\r"            ).should eq "abc\nd ef"    .mb_chars }
+    it { subject.chomp("abc\nd ef\r\n".mb_chars, "\n"              ).should eq "abc\nd ef"    .mb_chars }
+
+    it { subject.chomp("abcdef ghijkl".mb_chars                    ).should eq "abcdef ghijkl".mb_chars }
+    it { subject.chomp("abcdef ghij\n".mb_chars                    ).should eq "abcdef ghij"  .mb_chars }
+    it { subject.chomp("abc\nd efghij".mb_chars                    ).should eq "abc\nd efghij".mb_chars }
+    it { subject.chomp("abc\nd ef\n\r".mb_chars                    ).should eq "abc\nd ef\n"  .mb_chars }
+    it { subject.chomp("abc\nd ef\r\n".mb_chars                    ).should eq "abc\nd ef"    .mb_chars }
+    it { subject.chomp("abcdef ghijkl".mb_chars, "jkl"    .mb_chars).should eq "abcdef ghi"   .mb_chars }
+    it { subject.chomp("abcdef ghij\n".mb_chars, "j\n"    .mb_chars).should eq "abcdef ghi"   .mb_chars }
+    it { subject.chomp("abc\nd efghij".mb_chars, " efghij".mb_chars).should eq "abc\nd"       .mb_chars }
+    it { subject.chomp("abc\nd ef\n\r".mb_chars, "\n\r"   .mb_chars).should eq "abc\nd ef"    .mb_chars }
+    it { subject.chomp("abc\nd ef\r\n".mb_chars, "\n"     .mb_chars).should eq "abc\nd ef"    .mb_chars }
+
+    it { subject.chomp("abcdef ghijkl"                             ).should be_a String }
+    it { subject.chomp("abcdef ghij\n"                             ).should be_a String }
+    it { subject.chomp("abc\nd efghij"                             ).should be_a String }
+    it { subject.chomp("abc\nd ef\n\r"                             ).should be_a String }
+    it { subject.chomp("abc\nd ef\r\n"                             ).should be_a String }
+    it { subject.chomp("abcdef ghijkl", "jkl"                      ).should be_a String }
+    it { subject.chomp("abcdef ghij\n", "j\n"                      ).should be_a String }
+    it { subject.chomp("abc\nd efghij", " efghij"                  ).should be_a String }
+    it { subject.chomp("abc\nd ef\n\r", "\n\r"                     ).should be_a String }
+    it { subject.chomp("abc\nd ef\r\n", "\n"                       ).should be_a String }
+
+    it { subject.chomp("abcdef ghijkl"                             ).should be_a String }
+    it { subject.chomp("abcdef ghij\n"                             ).should be_a String }
+    it { subject.chomp("abc\nd efghij"                             ).should be_a String }
+    it { subject.chomp("abc\nd ef\n\r"                             ).should be_a String }
+    it { subject.chomp("abc\nd ef\r\n"                             ).should be_a String }
+    it { subject.chomp("abcdef ghijkl", "jkl"    .mb_chars         ).should be_a String }
+    it { subject.chomp("abcdef ghij\n", "j\n"    .mb_chars         ).should be_a String }
+    it { subject.chomp("abc\nd efghij", " efghij".mb_chars         ).should be_a String }
+    it { subject.chomp("abc\nd ef\n\r", "\n\r"   .mb_chars         ).should be_a String }
+    it { subject.chomp("abc\nd ef\r\n", "\n"     .mb_chars         ).should be_a String }
+
+    it { subject.chomp("abcdef ghijkl".mb_chars                    ).should be_a mb_chars }
+    it { subject.chomp("abcdef ghij\n".mb_chars                    ).should be_a mb_chars }
+    it { subject.chomp("abc\nd efghij".mb_chars                    ).should be_a mb_chars }
+    it { subject.chomp("abc\nd ef\n\r".mb_chars                    ).should be_a mb_chars }
+    it { subject.chomp("abc\nd ef\r\n".mb_chars                    ).should be_a mb_chars }
+    it { subject.chomp("abcdef ghijkl".mb_chars, "jkl"             ).should be_a mb_chars }
+    it { subject.chomp("abcdef ghij\n".mb_chars, "j\n"             ).should be_a mb_chars }
+    it { subject.chomp("abc\nd efghij".mb_chars, " efghij"         ).should be_a mb_chars }
+    it { subject.chomp("abc\nd ef\n\r".mb_chars, "\n\r"            ).should be_a mb_chars }
+    it { subject.chomp("abc\nd ef\r\n".mb_chars, "\n"              ).should be_a mb_chars }
+
+    it { subject.chomp("abcdef ghijkl".mb_chars                    ).should be_a mb_chars }
+    it { subject.chomp("abcdef ghij\n".mb_chars                    ).should be_a mb_chars }
+    it { subject.chomp("abc\nd efghij".mb_chars                    ).should be_a mb_chars }
+    it { subject.chomp("abc\nd ef\n\r".mb_chars                    ).should be_a mb_chars }
+    it { subject.chomp("abc\nd ef\r\n".mb_chars                    ).should be_a mb_chars }
+    it { subject.chomp("abcdef ghijkl".mb_chars, "jkl"    .mb_chars).should be_a mb_chars }
+    it { subject.chomp("abcdef ghij\n".mb_chars, "j\n"    .mb_chars).should be_a mb_chars }
+    it { subject.chomp("abc\nd efghij".mb_chars, " efghij".mb_chars).should be_a mb_chars }
+    it { subject.chomp("abc\nd ef\n\r".mb_chars, "\n\r"   .mb_chars).should be_a mb_chars }
+    it { subject.chomp("abc\nd ef\r\n".mb_chars, "\n"     .mb_chars).should be_a mb_chars }
+
+    it { subject.chomp(100                   ).should eq 100 }
+    it { subject.chomp(nil                   ).should be_nil }
+  end
+
   describe "::dasherize" do
     it { subject.dasherize("string_inflections"         ).should eq "string-inflections" }
     it { subject.dasherize("string_inflections"         ).should be_a String }
@@ -43,6 +230,26 @@ describe Normatron::Filters do
     it { subject.downcase(nil                     ).should be_nil }
   end
 
+  #
+  # DUMP
+  ###################################################################################################################
+  describe "::dump" do
+    it { subject.dump("abc\ndef"         ).should eq '"abc\ndef"'   }
+    it { subject.dump('abc\ndef'         ).should eq '"abc\\\ndef"' }
+
+    it { subject.dump("abc\ndef".mb_chars).should eq '"abc\ndef"'  .mb_chars }
+    it { subject.dump('abc\ndef'.mb_chars).should eq '"abc\\\ndef"'.mb_chars }
+
+    it { subject.dump("abc\ndef"         ).should be_a String }
+    it { subject.dump('abc\ndef'         ).should be_a String }
+
+    it { subject.dump("abc\ndef".mb_chars).should be_a mb_chars }
+    it { subject.dump('abc\ndef'.mb_chars).should be_a mb_chars }
+
+    it { subject.dump(100                     ).should eq 100 }
+    it { subject.dump(nil                     ).should be_nil }
+  end
+
   describe "::keep" do
     it { subject.keep("1111aaaa", :L         ).should eq "aaaa" }
     it { subject.keep("1111ܑܑܑܑ", :M          ).should eq "ܑܑܑܑ" }
@@ -189,6 +396,42 @@ describe Normatron::Filters do
     it { subject.strip(nil                    ).should be_nil }
   end
 
+  #
+  # SWAPCASE
+  ###################################################################################################################
+  describe "::swapcase" do
+    it { subject.swapcase("aeiouáéíóú"         ).should eq "AEIOUÁÉÍÓÚ" }
+    it { subject.swapcase("AEIOUÁÉÍÓÚ"         ).should eq "aeiouáéíóú" }
+    it { subject.swapcase("aEiOuÁéÍóÚ"         ).should eq "AeIoUáÉíÓú" }
+    it { subject.swapcase("AeIoUáÉíÓú"         ).should eq "aEiOuÁéÍóÚ" }
+
+    it { subject.swapcase("aeiouáéíóú".mb_chars).should eq "AEIOUÁÉÍÓÚ".mb_chars }
+    it { subject.swapcase("AEIOUÁÉÍÓÚ".mb_chars).should eq "aeiouáéíóú".mb_chars }
+    it { subject.swapcase("aEiOuÁéÍóÚ".mb_chars).should eq "AeIoUáÉíÓú".mb_chars }
+    it { subject.swapcase("AeIoUáÉíÓú".mb_chars).should eq "aEiOuÁéÍóÚ".mb_chars }
+
+    it { subject.swapcase("aeiouáéíóú"         ).should be_a String }
+    it { subject.swapcase("AEIOUÁÉÍÓÚ"         ).should be_a String }
+    it { subject.swapcase("aEiOuÁéÍóÚ"         ).should be_a String }
+    it { subject.swapcase("AeIoUáÉíÓú"         ).should be_a String }
+    
+    it { subject.swapcase("aeiouáéíóú".mb_chars).should be_a mb_chars }
+    it { subject.swapcase("AEIOUÁÉÍÓÚ".mb_chars).should be_a mb_chars }
+    it { subject.swapcase("aEiOuÁéÍóÚ".mb_chars).should be_a mb_chars }
+    it { subject.swapcase("AeIoUáÉíÓú".mb_chars).should be_a mb_chars }
+
+    it { subject.swapcase(100                  ).should eq 100 }
+    it { subject.swapcase(nil                  ).should be_nil }
+  end
+
+  describe "::titleize" do
+    pending
+  end
+
+  describe "::underscore" do
+    pending
+  end
+
   describe "::upcase" do
     it { subject.upcase("Çsdf !@# éhas"         ).should eq "ÇSDF !@# ÉHAS" }
     it { subject.upcase("Çsdf !@# éhas"         ).should be_a String }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: normatron
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-23 00:00:00.000000000 Z
+date: 2012-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -75,10 +75,10 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.10.0
-description: ! "    Normatron is an attribute normalizer for ActiveRecord objects.\n
-  \   With it you can convert attributes to the desired format before saving them
-  in the database.\n    This gem inhibits the work of having to override attributes
-  or create a specific method to perform most of the normalizations.\n"
+description: ! "    Normatron is an Ruby On Rails plugin that perform attribute normalizations
+  for ActiveRecord objects.\n    With it you can normalize attributes to the desired
+  format before saving them in the database.\n    This gem inhibits the work of having
+  to override attributes or create a specific method to perform most of the normalizations.\n"
 email:
 - fernandors87@gmail.com
 executables: []