normatron 0.2.1 → 0.3.0

data/README.textile

@@ -1,6 +1,6 @@
 h1. Normatron
 
-Normatron is an Ruby On Rails plugin that perform attribute normalizations for ActiveRecord objects.
+Normatron is a 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.
 
@@ -18,6 +18,10 @@ Or install it by yourself:
 
 pre. $ gem install normatron
 
+Then run the generator:
+
+pre. $ rails generator normatron:install
+
 h2. The problem
 
 Suppose you have a product model as the following:
@@ -41,15 +45,15 @@ And we want the _name_ attribute be uppercased before saving it into the databas
 The most usual approach to do this includes:
 
 * Override the _name_ setter and convert the value to an uppercased string.
-* Use the "_before_validation_":http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html callback to run a method or block doing the task.
+* Write a method or block and bind it to the "before_validation":http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html callback.
 
 Both ways are ilenegant, boring, error prone and very expensive.
 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/SquishFilter and ":blank":http://rubydoc.info/gems/normatron/Normatron/Filters/BlankFilter as default filters.
+These filters are applied to all attributes through "normalize":http://rubydoc.info/gems/normatron/Normatron/Extensions/ActiveRecord/ClassMethods#normalize-instance_method function, since no options is given.
 
 pre. # ./app/models/products.rb
 class Product < ActiveRecord::Base
@@ -58,48 +62,30 @@ class Product < ActiveRecord::Base
 end
 
 pre.  $ rails console
- > p1 = Product.create name: "  memory   card    "
+ > memory = Product.create name: "  memory   card    "
 => #<Product id: nil, name: "memory card", price: nil>
- > p2 = Product.create name: "    "
+ > null = Product.create name: "    "
 => #<Product id: nil, name: nil, price: nil>
 
-h3. The _normalize_attributes_ method
+h3. Configurations
 
-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.
+"normatron:install":http://rubydoc.info/gems/normatron/Normatron/InstallGenerator generator creates a configuration file located at @./config/initializers/normatron.rb@.
 
-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>
+For now, you can set the default normalization filters or disable normatron by commenting the @add_orm@ line.
 
-h3. The _normalize_options_ method
+h3. Applying normalizations
 
-To read the normalization filters set for a model, just call the @normalize_options@ method.
+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 "apply_normalizations":http://rubydoc.info/gems/normatron/Normatron/Extensions/ActiveRecord/InstanceMethods#apply_normalizations-instance_method 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
- > Product.normalize_options
-=> { name: { :squish => [], :blank => [] } }
-
-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:
+ > product = Product.new name: "  hard    drive"
+=> #<Product id: nil, name: "  hard    drive", price: nil>
+ > product.apply_normalizations
+ > product
+=> #<Product id: nil, name: "hard drive", price: nil>
 
-pre.  $ rails console
- > MyModel.normalize_options
-=> { :attribute_a => { :filter_a => [] },
-     :attribute_b => { :filter_a => [],
-                       :filter_b => [arg_a, arg_b] },
-     :attribute_c => { :filter_b => [arg_a, arg_b],
-                       :filter_c => [arg],
-                       :filter_d => [] },
-     :attribute_d => { :filter_a => [],
-                       :filter_c => [arg],
-                       :filter_d => [arg_a, arg_b, arg_c, arg_d] } }
-
-h3. The _:with_ option
+h3. Setting normalization rules
 
 The @:with@ option allows to bind filters to one or more attribute.
 
@@ -108,11 +94,11 @@ pre. class Product < ActiveRecord::Base
 end
 
 pre.  $ rails console
- > Product.normalize_options
+ > Product.normalize_filters
 => { :name => { :upcase => [] } }
 
 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.
+When "normalize":http://rubydoc.info/gems/normatron/Normatron/Extensions/ActiveRecord/ClassMethods#normalize-instance_method method is used multiple times for the same attribute, it will stack the filter bindings.
 
 pre. class Product < ActiveRecord::Base
   normalize :name
@@ -120,7 +106,7 @@ pre. class Product < ActiveRecord::Base
 end
 
 pre.  $ rails console
- > Product.normalize_options
+ > Product.normalize_filters
 => { :name => { :squish => [],
                 :blank  => [],
                 :upcase => [] } }
@@ -137,7 +123,7 @@ a) Using a Hash where the key is the filter name and the value is an arguments A
 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] } ]
+  normalize :brand,       :with => { :squeeze => ["a-z"] }
 end
 
 b) Using an Array where the first element if the attribute name and rest is the filter arguments.
@@ -145,18 +131,17 @@ b) Using an Array where the first element if the attribute name and rest is the
 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] ]
+  normalize :brand,       :with => [ [:squeeze, "a-z"] ]
 end
 
 Both ways will produce the same result:
 
 pre.  $ rails console
- > Product.normalize_options
+ > Product.normalize_filters
 => { :name        => { :keep    => [:Latin],
                        :remove  => [:Nd, :Zs] },
      :description => { :squeeze => [] },
-     :brand       => { :squeeze => ["a-z"],
-                       :keep    => [:Word] } }
+     :brand       => { :squeeze => ["a-z"] } }
 
 h3. Using instance method as filter
 
@@ -186,7 +171,7 @@ end
 
 h2. Filters
 
-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.
+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.
 
 h1. Contributing
 
@@ -204,9 +189,11 @@ There are several ways to make this gem even better:
 
 h1. Credits
 
-This gem was initially inspired on these gems:
-* "normalize_attributes (normalize_attributes Gem)":https://github.com/fnando/normalize_attributes - "fnando (fnando's Github)":https://github.com/fnando 
-* "attribute_normalizer (attribute_normalizer Gem)":https://github.com/mdeering/attribute_normalizer - "mdeering (mdeering's Github)":https://github.com/mdeering
+This gem was initially inspired on:
+* "normalize_attributes (normalize_attributes Gem)":https://github.com/fnando/normalize_attributes - I liked the cleaner code and simplicity of this gem.
+* "attribute_normalizer (attribute_normalizer Gem)":https://github.com/mdeering/attribute_normalizer - Very powerful.
+
+The idea is to mix the good things of both gems, adding some features and changing something to fit my taste.
 
 h1. License
 

data/Rakefile

@@ -1,4 +1,5 @@
 #!/usr/bin/env rake
+=begin
 begin
   require 'bundler/setup'
 rescue LoadError
@@ -22,13 +23,11 @@ end
 
 Bundler::GemHelper.install_tasks
 
-require 'rake/testtask'
+=end
+require 'rspec/core/rake_task'
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = '--color -f d'
 end
 
-task :default => :test
+task :default => :spec

data/lib/generators/normatron/install_generator.rb

@@ -0,0 +1,23 @@
+module Normatron
+  ##
+  # Creates all necessary files to run Normatron in your Ruby On Rails project.
+  #
+  # These files are:
+  # * config/initializers/normatron.rb
+  #
+  # *Usage:*
+  #   $ rails generator normatron:install
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+    desc "Create all necessary files to run Normatron in your Ruby On Rails project."
+
+    ##
+    # Copy files from templates to their respective destination
+    #
+    # These files are:
+    # * config/initializers/normatron.rb
+    def copy_files
+      copy_file "normatron.rb", "config/initializers/normatron.rb"
+    end
+  end
+end

data/lib/generators/normatron/templates/normatron.rb

@@ -0,0 +1,4 @@
+Normatron.setup do |config|
+  config.default_filters = :blank, :squish
+  config.add_orm Normatron::Extensions::ActiveRecord
+end

data/lib/normatron.rb

@@ -1,20 +1,34 @@
 require "normatron/configuration"
-require "normatron/extensions/active_record"
+require "normatron/extensions"
 
 module Normatron
-  VERSION = "0.2.1"
-
   class << self
     def configuration
       @configuration ||= Configuration.new
     end
     alias :config :configuration
 
-    def configure
+    def setup
       yield(configuration)
     end
-    alias :setup :configure
-  end
-end
 
-ActiveRecord::Base.send(:include, Normatron::Extensions::ActiveRecord) if defined?(ActiveRecord::Base)
+    def build_hash(*terms)
+      terms.flatten!(1)
+
+      filters_hash = {}
+      terms.each do |term|
+        case term
+          when Array
+            key, value = term.first, term.drop(1)
+            filters_hash[key.to_sym] = value.kind_of?(Array) && value.empty? ? nil : value
+          when Hash
+            term.each { |key, value| filters_hash[key.to_sym] = *value }
+          else
+            filters_hash[term.to_sym] = nil
+        end
+      end
+
+      filters_hash
+    end
+  end
+end

data/lib/normatron/configuration.rb

@@ -1,34 +1,38 @@
+require 'normatron/filters'
+
 module Normatron
   class Configuration
-    def self.clean_filters(*with)
-      elements = with.flatten(1)
-      raise "empty" unless elements.any?
-
-      result = {}
-      elements.each do |e|
-        case e
-        when Array
-          result[e[0].to_sym] = e[1..-1]
-        when Hash
-          e.each { |key, value| result[key] = *value.flatten(1) }
-        else
-          result[e.to_sym] = []
-        end
-      end
-
-      result
-    end
+    attr_reader   :default_filters
+    attr_accessor :filters
 
     def initialize
-      @default_filters = { squish: [], blank: [] }
+      @default_filters = { blank: nil, squish: nil }
+
+      @filters = {}
+      @filters[:blank]      = Normatron::Filters::BlankFilter
+      @filters[:camelize]   = Normatron::Filters::CamelizeFilter
+      @filters[:capitalize] = Normatron::Filters::CapitalizeFilter
+      @filters[:chomp]      = Normatron::Filters::ChompFilter
+      @filters[:dasherize]  = Normatron::Filters::DasherizeFilter
+      @filters[:downcase]   = Normatron::Filters::DowncaseFilter
+      @filters[:dump]       = Normatron::Filters::DumpFilter
+      @filters[:keep]       = Normatron::Filters::KeepFilter
+      @filters[:remove]     = Normatron::Filters::RemoveFilter
+      @filters[:squeeze]    = Normatron::Filters::SqueezeFilter
+      @filters[:squish]     = Normatron::Filters::SquishFilter
+      @filters[:strip]      = Normatron::Filters::StripFilter
+      @filters[:swapcase]   = Normatron::Filters::SwapcaseFilter
+      @filters[:titleize]   = Normatron::Filters::TitleizeFilter
+      @filters[:underscore] = Normatron::Filters::UnderscoreFilter
+      @filters[:upcase]     = Normatron::Filters::UpcaseFilter
     end
 
-    def default_filters
-      @default_filters
+    def add_orm(extension)
+      extension::ORM_CLASS.send(:include, extension)
     end
 
     def default_filters=(filters)
-      @default_filters = self.class.clean_filters(filters)
+      @default_filters = Normatron.build_hash(filters)
     end
   end
 end

data/lib/normatron/extensions.rb

@@ -0,0 +1,8 @@
+require 'normatron/extensions/active_record'
+
+module Normatron
+  module Extensions
+    class UnknownAttributeError < RuntimeError ; end
+    class UnknownFilterError < RuntimeError ; end
+  end
+end

data/lib/normatron/extensions/active_record.rb

@@ -1,16 +1,19 @@
-require "normatron/filters"
+require 'active_record'
 
 module Normatron
   module Extensions
     module ActiveRecord
+
+      ORM_CLASS = ::ActiveRecord::Base
+
       def self.included(base)
         base.instance_eval do
           extend ClassMethods
           include InstanceMethods
-          before_validation :normalize_attributes
+          before_validation :apply_normalizations
 
           class << self
-            attr_accessor :normalize_options
+            attr_accessor :normalize_filters
           end
         end
       end
@@ -19,38 +22,40 @@ module Normatron
         def normalize(*args)
           # Check existence of all attributes
           options = args.extract_options!
-          args, columns = args.map(&:to_sym), column_names.map(&:to_sym)
-          raise "attribute" if (columns & args).size != args.size
+          filters, columns = args.map(&:to_s), column_names
+          raise UnknownAttributeError if (columns & filters).size != filters.size
 
           # Specify the use of default filters or not
           if options[:with].nil? || options[:with].blank?
             new_filters = Normatron.config.default_filters
           else
-            new_filters = Normatron::Configuration.clean_filters(options[:with])
+            new_filters = Normatron.build_hash(options[:with])
           end
 
           # Append to older filters hash
-          @normalize_options ||= {}
-          @normalize_options =
-          args.reduce(@normalize_options) do |hash, att|
-            filters = (@normalize_options[att] || {}).merge(new_filters)
+          @normalize_filters ||= {}
+          @normalize_filters =
+          args.reduce(@normalize_filters) do |hash, att|
+            filters = (@normalize_filters[att] || {}).merge(new_filters)
             hash.merge({att => filters})
           end
         end
       end
 
       module InstanceMethods
-        def normalize_attributes
-          self.class.normalize_options.each do |attribute, filters|
+        def apply_normalizations
+          named_filters = Normatron.configuration.filters
+
+          self.class.normalize_filters.each do |attribute, filters|
             value = send("#{attribute}_before_type_cast") || send(attribute)
 
             filters.each do |filter, args|
               if self.respond_to? filter
                 value = send(filter, value, *args)
-              elsif Normatron::Filters.respond_to? filter
-                value = Normatron::Filters.send(filter, value, *args)
+              elsif !named_filters[filter].nil?
+                value = named_filters[filter].evaluate(value, *args)
               else
-                raise "Filter '#{filter}' wasn't found."
+                raise UnknownFilterError
               end
             end
 

data/lib/normatron/filters.rb

@@ -1,384 +1,31 @@
-# encoding: UTF-8
-
-require 'active_support/multibyte/chars'
-require 'active_support/core_ext/string'
-require 'active_support/inflector/inflections'
+require 'normatron/filters/blank_filter'
+require 'normatron/filters/camelize_filter'
+require 'normatron/filters/capitalize_filter'
+require 'normatron/filters/chomp_filter'
+require 'normatron/filters/dasherize_filter'
+require 'normatron/filters/downcase_filter'
+require 'normatron/filters/dump_filter'
+require 'normatron/filters/keep_filter'
+require 'normatron/filters/remove_filter'
+require 'normatron/filters/squeeze_filter'
+require 'normatron/filters/squish_filter'
+require 'normatron/filters/strip_filter'
+require 'normatron/filters/swapcase_filter'
+require 'normatron/filters/titleize_filter'
+require 'normatron/filters/underscore_filter'
+require 'normatron/filters/upcase_filter'
 
 module Normatron
+  # Top-Level namespace of all native Normatron filters.
+  #
+  # All filters share some characteristics:
+  # * They have the <code>Filter</code> suffix in the name.
+  # * Has a class method called <code>evaluate</code>, which runs what the filter claims to do.
+  # * The first argument of the method <code>evaluate</code> always will be the variable to be filtered.
+  # * They returns a different object from the input variable, ie, even if the value remains unchanged, the <code>object_id</code> of both variables will be different.
+  # * They treat accented characters and not just <code>/[a-zA-Z]/</code> interval.
   module Filters
-    extend self
-
-    ##
-    # Returns a <tt>Nil</tt> object for a blank string or the string itself otherwise.
-    # 
-    # @example
-    #   blank("")            #=> nil
-    #   blank("     ")       #=> nil
-    #   blank("   \n   ")    #=> nil
-    #   blank("1")           #=> "1"
-    #   blank("It's blank?") #=> "It's blank?"
-    #   blank(123)           #=> 123
-    #
-    #   # 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 blank(value)
-      return value unless string?(value) && value.to_s.blank?
-      nil
-    end
-
-    ##
-    # 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("jESSE PINK")   #=> "Jesse pink"
-    #   capitalize("wALTER WHITE") #=> "Walter white"
-    #   capitalize(" mr. Fring")   #=> " mr. fring"
-    #   capitalize(123)            #=> 123
-    #
-    #   # 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 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.
-    # 
-    # @example
-    #   dasherize("monty_python") #=> "monty-python"
-    #   dasherize("_.·-'*'-·._")  #=> "-.·-'*'-·.-"
-    #   dasherize(123)            #=> 123
-    #
-    #   # 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 dasherize(value)
-      (string?(value) && eval_send(:dasherize, value)) || value
-    end
-
-    ##
-    # Lowercase all characters.
-    # 
-    # @example
-    #   downcase("VEGETA!!!") #=> "vegeta!!!"
-    #   downcase(123)         #=> 123
-    #
-    #   # 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 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.
-    # 
-    # @example
-    #   keep("Doom 3", :L)      #=> "Doom"    equivalent to /\p{L}/u
-    #   keep("Doom 3", :N)      #=> "3"       equivalent to /\p{N}/u
-    #   keep("Doom 3", :L, :N)  #=> "Doom3"   equivalent to /\p{L}\p{N}/u
-    #   keep("Doom 3", :Lu, :N) #=> "D3"      equivalent to /\p{Lu}\p{N}/u
-    #   keep("Doom ˩", :Latin)  #=> "Doom"    equivalent to /\p{Latin}/u
-    #
-    #   # For normalizations
-    #   normalize :attribute_a, :with => [[:keep, :Lu, :N]]
-    #   normalize :attribute_b, :with => [:custom_filter, [:keep, :L, :Nd]]
-    #   normalize :attribute_c, :with => [:custom_filter, {:keep => [:Latin, :Z]}]
-    # @param [String] value A character sequence
-    # @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 keep(value, *args)
-      eval_regexp(value, true, args)
-    end
-
-    ##
-    # Remove trailing spaces.
-    # 
-    # @example
-    #   lstrip("   copyleft   ") #=> "copyleft   "
-    #
-    #   # For normalizations
-    #   normalize :attribute, :with => [:custom_filter, :lstrip]
-    # @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 lstrip(value)
-      (string?(value) && eval_strip(value, true, false)) || value
-    end
-
-    ##
-    # Remove only the specified characters.
-    # Details about the options can be found in the Regexp class documentation.
-    # 
-    # @example
-    #   remove("Quake 3", :L)      #=> "3"            equivalent to /\p{L}/u
-    #   remove("Quake 3", :N)      #=> "Quake "       equivalent to /\p{N}/u
-    #   remove("Quake 3", :L, :N)  #=> " "            equivalent to /\p{L}\p{N}/u
-    #   remove("Quake 3", :Lu, :N) #=> "uake "        equivalent to /\p{Lu}\p{N}/u
-    #   remove("Quake ˩", :Latin)  #=> "Quake"        equivalent to /\p{Latin}/u
-    #
-    #   # For normalizations
-    #   normalize :attribute_a, :with => [[:remove, :Lu, :N]]
-    #   normalize :attribute_b, :with => [:custom_filter, [:remove, :L, :Nd]]
-    #   normalize :attribute_c, :with => [:custom_filter, {:remove => [:Latin, :Z]}]
-    # @param [String] value A character sequence
-    # @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 remove(value, *args)
-      eval_regexp(value, false, args)
-    end
-
-    ##
-    # Remove leading spaces.
-    # 
-    # @example
-    #   rstrip("   copyright   ") #=> "   copyright"
-    #
-    #   # For normalizations
-    #   normalize :attribute, :with => [:custom_filter, :rstrip]
-    # @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 rstrip(value)
-      (string?(value) && eval_strip(value, false, true)) || value
-    end
-
-    ##
-    # Remove multiple occurences of the same character.
-    # If no option are given, all runs of identical characters are replaced by a single character.
-    # 
-    # @example
-    #   squeeze("yellow moon")                  #=> "yelow mon"
-    #   squeeze("  now   is  the", " ")         #=> " now is the"
-    #   squeeze("putters shoot balls", "m-z")   #=> "puters shot balls"
-    #
-    #   # For normalizations
-    #   normalize :attribute_a, :with => [:custom_filter, :squeeze]
-    #   normalize :attribute_b, :with => [:custom_filter, [:squeeze, "a-f"]]
-    #   normalize :attribute_c, :with => [:custom_filter, {:squeeze => ["a-f"]}]
-    # @param [String] value A character sequence
-    # @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 squeeze(value, *args)
-      return value unless string?(value)
-      (args.any? && value.squeeze(args.first)) || value.squeeze
-    end
-
-    ##
-    # Strip and remove multiple spaces.
-    # 
-    # @example
-    #   squish("  the \n simpsons ") #=> "the simpsons"
-    #
-    #   # For normalizations
-    #   normalize :attribute, :with => [:custom_filter, :squish]
-    # @param [String] value A character sequence
-    # @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 squish(value)
-      (string?(value) && value.squish) || value
-    end
-
-    ##
-    # Remove traling and leading spaces from the string.
-    # 
-    # @example
-    #   strip("   copy   ") #=> "copy"
-    #
-    #   # For normalizations
-    #   normalize :attribute, :with => [:custom_filter, :strip]
-    # @param [String] value A character sequence
-    # @return [String, Object] The stripped character sequence or the object itself
-    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.
-    # 
-    # @example
-    #   downcase("kakarotto!!!") #=> "KAKAROTTO!!!"
-    #   downcase(123)            #=> 123
-    #
-    #   # For normalizations
-    #   normalize :attribute, :with => [:custom_filter, :upcase]
-    # @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-upcase String#upcase
-    # @see http://api.rubyonrails.org/classes/ActiveSupport/Multibyte/Chars.html#method-i-upcase ActiveSupport::Multibyte::Chars#upcase
-    def upcase(value)
-      (string?(value) && eval_send(:upcase, value)) || value
-    end
-
-    protected
-
-    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.prepend('^') if keep
-      regex = eval "/[#{regex}]/u"
-
-      value.gsub(regex, "")
-    end
-
-    def eval_send(method, value, option=nil)
-      type = value.class
-      value = value.mb_chars if type == String
-      if option
-        value = value.send(method, option)
-      else
-        value = value.send(method)
-      end
-      (type == String && value.to_s) || value
-    end
-
-    def eval_strip(value, start, ending)
-      regex = []
-      regex << '\A\p{Zs}*' if start
-      regex << '\p{Zs}*\z' if ending
-      regex = eval "/#{regex * '|'}/u"
+  end
+end
 
-      value.gsub(regex, '')
-    end
 
-    def string?(value)
-      value.is_a?(ActiveSupport::Multibyte::Chars) || value.is_a?(String)
-    end
-  end
-end