normatron 0.0.6 → 0.0.7

data/README.textile

@@ -0,0 +1,191 @@
+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.
+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>
+
+And then bundle it up:
+
+<pre>$ bundle install</pre>
+
+Or install it by yourself:
+
+<pre>$ gem install normatron</pre>
+
+h2. The problem
+
+Suppose you have a product model as the following:
+
+<pre>
+# ./db/migrate/20120101010000_create_products.rb
+class CreateProducts < ActiveRecord::Migration
+  def change
+    create_table :products do |t|
+      t.string  :name
+      t.decimal :price, :precision => 10, :scale => 2
+    end
+  end
+end
+
+# ./app/models/products.rb
+class Product < ActiveRecord::Base
+  attr_accessible :name, :price
+end
+</pre>
+
+And you 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.
+
+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:
+
+h2. Usage
+
+h3. Single attribute with standard filters
+
+<pre>
+# ./app/models/products.rb
+class Product < ActiveRecord::Base
+  attr_accessible :name, :price
+  normalize :name
+end
+
+$ rails console
+> pa = Product.create :name => "  memory   card    "
+> pa.name
+=> "memory card"
+> pb = Product.create :name => "    "
+> pb.name
+=> nil
+</pre>
+
+Normatron will use *:squish* and *:blank* filters if no option was given.
+
+h3. Multiple filters to a single attribute
+
+<pre>normalize :name, :with => [:blank, :squish, :upcase]</pre>
+
+Just add the *:with* option and pass the filters as an array.
+
+h3. Multiple attributes with same filters
+
+<pre>normalize :name, :brand, :with => [:capitalize, :blank]</pre>
+
+All symbols outside the *:with* option are flagged as an attribute.
+
+h3. Multiple attributes with different filters
+
+<pre>
+# ./app/models/user.rb
+class User < ActiveRecord::Base
+  attr_accessible :name, :surname, :login, :password, :email
+  normalize :name, :surname, :email, :login, :with => [:blank, :squish]
+  normalize :name, :surname, :with => :upcase
+  normalize :email, :with => :downcase
+end
+
+$ rails console
+> u = User.create :name => " c  h  u  c  k", :surname => "  norris   ", :email => "IKillYou@MostBadass.com", :login => "ALLineedislove"
+> u.name
+=> "C H U C K"
+> u.surname
+=> "NORRIS"
+> u.email
+=> "ikillyou@mostbadass.com"
+</pre>
+
+You can stack filters to an attribute calling the *normalize* method multiple times.
+
+h3. Using custom instance method as a filter
+
+<pre>
+# ./app/models/client.rb
+class Client < ActiveRecord::Base
+  attr_accessible :name, :phone
+
+  normalize :phone, :with => :my_phone_filter
+
+  def my_phone_filter(value)
+    digits = value.gsub(/[^\d]/, '')
+    "(%s) %s-%s" % [digits[0..1], digits[2..5], digits[6..9]]
+  end
+end
+
+$ rails console
+> p = Client.create :name => "Jim Raynor", :phone => " a1b c2d e3f g4h i5j k6l m7n o8p q9r s1t "
+> p.phone
+=> "(12) 3456-7891"
+</pre>
+
+Create an instance method that returns the value as you want. The method must have an unique mandatory parameter.
+
+h2. Filters
+
+table{border:1px solid black}.
+|_. FILTER|_. INPUT|_.OUTPUT|
+|:blank|"text"|"text"|
+|:blank|" "|nil|
+|:blank|"\n"|nil|
+|:blank|""|nil|
+|:capitalize|"power overwhelming"|"Power overwhelming"|
+|:capitalize|"POWER overwhelming"|"Power overwhelming"|
+|:capitalize|" power overwhelming"|" power overwhelming"|
+|:downcase|"EDWARD"|"edward"|
+|:lstrip|" Chrono Trigger "|"Chrono Trigger "|
+|:rstrip|" Chrono Cross "|" Chrono Cross"|
+|:squish|" "|""|
+|:squish|" \n \r \t \f "|""|
+|:squish|" Master of Puppets "|"Master of Puppets"|
+|:strip|" Final Fantasy "|"Final Fantasy"|
+|:titlecase or :titleize|" system of a down "|" System Of A Down "|
+|:upcase|"text"|"TEXT"|
+
+h1. Changelog
+
+- 0.0.7 :=
+* Ability to use an instance method as a filter
+=:
+
+h1. Contributing
+
+* Fork it, add your new features or bug fixes, make your tests and commit.
+* Report any bug or unexpected behavior.
+* Send me your feedback.
+* Pay me a beer. =]
+
+h1. Special Thanks
+
+This gem was inspired on work of "fnando (fnando's Github)":https://github.com/fnando called "normalize_attributes (normalize_attributes gem)":https://github.com/fnando/normalize_attributes.
+He have a lot of interesting gems on his repo, please take a look.
+
+h1. Licence
+
+Copyright 2012 Fernando Rodrigues da Silva
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/normatron.rb

@@ -1,7 +1,19 @@
-require "normatron/active_record"
+require "normatron/configuration"
+require "normatron/extensions/active_record"
 
 module Normatron
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end   
+
+    def configure
+      yield(configuration)
+    end
+    alias :setup :configure
+  end
 end
 
-ActiveRecord::Base.send :include, Normatron::ActiveRecord
+ActiveRecord::Base.send :include, Normatron::Extensions::ActiveRecord if defined?(ActiveRecord::Base)

data/lib/normatron/configuration.rb

@@ -0,0 +1,13 @@
+module Normatron
+  class Configuration
+    attr_writer :default_filters
+
+    def initialize
+      @default_filters ||= [:squish, :blank]
+    end
+
+    def default_filters
+      @default_filters = [@default_filters].flatten.compact.uniq
+    end
+  end
+end

data/lib/normatron/extensions/active_record.rb

@@ -0,0 +1,46 @@
+require "normatron/filters/native"
+
+module Normatron
+  module Extensions
+    module ActiveRecord
+      def self.included(base)
+        base.instance_eval do
+          before_validation :apply_normalizations
+
+          class << self
+            attr_accessor :normalize_options
+
+            def normalize(*args)
+              options = args.extract_options!
+              options[:with] ||= Normatron.configuration.default_filters
+              options[:with] = [options[:with]].flatten
+
+              @normalize_options ||= {}
+              args.each do |attribute|
+                @normalize_options[attribute] ||= []
+                @normalize_options[attribute] = options[:with]
+              end
+              @normalize_options
+            end
+          end
+        end
+      end
+
+      def apply_normalizations
+        self.class.normalize_options.each do |attribute, filters|
+          value = send("#{attribute}_before_type_cast") || send(attribute)
+
+          filters.each do |filter|
+            if self.respond_to? filter
+              value = send(filter, value)
+            else
+              value = Normatron::Filters::Native.apply(filter, value)
+            end
+          end
+
+          write_attribute attribute, value
+        end
+      end
+    end
+  end
+end

data/lib/normatron/filters/native.rb

@@ -0,0 +1,32 @@
+require "active_support/all"
+
+module Normatron
+  module Filters
+    module Native
+      class << self
+        def apply(filter, value)
+          return value unless value.is_a? String
+
+          case filter
+          when :upcase, :downcase, :capitalize, :titlecase, :titleize
+            value.mb_chars.send(filter).to_s
+          when :squish, :lstrip, :rstrip, :strip
+            value.send(filter)
+          when :blank
+            send("to_#{filter}", value)
+          end
+        end
+
+        def filter_names
+          [:upcase, :downcase, :capitalize, :titlecase, :titleize, :squish, :lstrip, :rstrip, :strip, :blank]
+        end
+
+        private
+
+        def to_blank(value)
+          value.blank? ? nil : value
+        end
+      end
+    end
+  end
+end

data/spec/lib/normatron/configuration_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Normatron::Configuration do
+
+  let(:klass)     { Normatron::Configuration }
+  let(:instance)  { @instance }
+
+  before :each do
+    @instance = klass.new
+  end
+
+  describe :default_filters do
+    it "should be initializated" do
+      instance.default_filters.should eq [:squish, :blank]
+    end
+
+    it "should be enclause values into an array" do
+      instance.default_filters = :a
+      instance.default_filters.should eq [:a]
+    end
+
+    it "should reject repeated filters" do
+      instance.default_filters = :a, :a
+      instance.default_filters.should eq [:a]
+
+      instance.default_filters += [:a, :b]
+      instance.default_filters.should eq [:a, :b]
+    end
+
+    it "should reject nil filters" do
+      instance.default_filters = nil
+      instance.default_filters.should eq []
+
+      instance.default_filters = :a, nil
+      instance.default_filters.should eq [:a]
+
+      instance.default_filters << nil
+      instance.default_filters.should eq [:a]
+    end
+  end
+
+  pending "should map filter modules"
+  pending "should allow create inline filters"
+  pending "should"
+end

data/spec/lib/normatron/extensions/active_record_spec.rb

@@ -0,0 +1,112 @@
+require "spec_helper"
+
+describe Normatron::Extensions::ActiveRecord do
+	let(:model_class) 		{ Client }
+
+	before :each do
+		model_class.normalize_options = {}
+	end
+
+	it "should allow get and set normalization options" do
+		model_class.normalize(:name, :cpf, with: [:a, :b]).should include(name: [:a, :b], cpf: [:a, :b])
+		model_class.normalize_options.should include(name: [:a, :b], cpf: [:a, :b])
+	end
+
+	it "should allow set multiple attributes" do
+		model_class.normalize(:name, :cpf, :phone)
+		model_class.normalize_options.should include(:name, :cpf, :phone)
+	end
+
+	it "should allow include single filter" do
+		model_class.normalize(:name, with: :a)
+		model_class.normalize_options.should include(name: [:a])
+	end
+
+	it "should allow include multiple filters" do
+		model_class.normalize(:name, with: [:a, :b])
+		model_class.normalize_options.should include(name: [:a, :b])
+	end
+
+  it "should include default filters" do
+    model_class.normalize(:name)
+    model_class.normalize_options.should include(name: [:squish, :blank])
+  end
+
+  it "should apply normalizations" do
+  	model_class.normalize(:name)
+  	instance = model_class.new
+  	instance.name = "   xxx   "
+  	instance.apply_normalizations
+  	instance.name.should eq "xxx"
+
+  	class Client < ActiveRecord::Base
+  		def my_filter(value)
+  			value.split(//) * "-"
+  		end
+  	end
+
+  	model_class.normalize(:name, with: :my_filter)
+  	instance = model_class.new
+  	instance.name = "xxx"
+  	instance.apply_normalizations
+  	instance.name.should eq "x-x-x"
+  end
+
+  pending "should apply default normalizations when :with is ommited"
+  pending "should apply instance methods normalizations"
+  pending "should apply blocks normalizations"
+  pending "should apply modules normalizations"
+  pending "should apply configuration blocks normalizations"
+
+  pending "should set default normalization filters" do
+  	pending "to single attribute"
+  	pending "to multiple attributes"
+  end
+  pending "should set single normalization filter" do
+  	pending "to single attribute"
+  	pending "to multiple attributes"
+  end
+  pending "should set multiple normalization filters" do
+  	pending "to single attribute"
+  	pending "to multiple attributes"
+  end
+  pending "should remove repeated normalization" do
+  	pending "attributes"
+  	pending "filters"
+  end
+  pending "should remove nil normalization" do
+  	pending "attributes"
+  	pending "filters"
+  end
+  pending "should ignore nil normalization" do
+  	pending "attribute"
+  	pending "filter"
+  end
+  pending "should apply normalizations" do
+  	pending "using a single filter" do
+  		pending "for a single attribute"
+  		pending "for all attributes"
+  	end
+  	pending "using multiple filters" do
+  		pending "for a single attribute"
+  		pending "for all attributes"
+  	end
+  	pending "specified into" do
+  		pending "native filters module"
+  		pending "custom filters module"
+  		pending "instance model"
+  		pending "instance block"
+  		pending "instance lambda"
+  		pending "configuration lambda"
+  	end
+  end
+  pending "should allow specify" do
+  	pending "when the normalizations will be done"
+  	pending "conditions to normalizations be done"
+  	pending "sequence of normalization chain"
+  end
+  pending "should raise exception" do
+  	pending "when given attribute doesn't exist"
+  	pending "when given filter doesn't exist"
+  end
+end

data/spec/lib/normatron_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe Normatron do
+  let(:mod)     { Normatron }
+  let(:config)  { Normatron.configuration }
+
+  describe "configuration" do
+    it "should respond to aliases" do
+      mod.should respond_to :configuration
+      mod.should respond_to :configure
+      mod.should respond_to :setup
+    end
+
+    it "should return configuration object" do
+      config.should be_an_instance_of Normatron::Configuration
+    end
+
+    it "should process given blocks" do
+      expect { |b| Normatron.setup(&b) }.to yield_control
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,8 +1,6 @@
 require "rspec"
+require "active_record"
 require "normatron"
 
 ActiveRecord::Base.establish_connection :adapter => "sqlite3", :database => ":memory:"
-
-
-
 Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }

data/spec/support/client_model.rb

@@ -0,0 +1,3 @@
+class Client < ActiveRecord::Base
+  attr_accessible :name, :credit_limit, :cpf, :birth_date, :phone, :login_count
+end

data/spec/support/schema.rb

@@ -1,6 +1,10 @@
 ActiveRecord::Schema.define(:version => 0) do
-  create_table :test_models do |t|
-    t.string :string_column
-    t.integer :integer_column
+  create_table :clients do |t|
+  	t.string 	:name
+  	t.decimal :credit_limit, precision: 10, scale: 2
+  	t.string 	:cpf
+  	t.date 		:birth_date
+  	t.string 	:phone
+  	t.integer :login_count
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: normatron
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-02 00:00:00.000000000 Z
+date: 2012-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -62,24 +62,26 @@ dependencies:
 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 the normalizations.\n"
+  or create a specific method to perform most of the normalizations.\n"
 email:
 - fernandors87@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/normatron/filters.rb
-- lib/normatron/active_record.rb
 - lib/normatron.rb
+- lib/normatron/configuration.rb
+- lib/normatron/filters/native.rb
+- lib/normatron/extensions/active_record.rb
 - MIT-LICENSE
 - Rakefile
-- README.rdoc
-- spec/support/test_model.rb
-- spec/support/schema.rb
-- spec/active_record_spec.rb
-- spec/filters_spec.rb
+- README.textile
+- spec/lib/normatron/configuration_spec.rb
+- spec/lib/normatron/extensions/active_record_spec.rb
+- spec/lib/normatron_spec.rb
 - spec/spec_helper.rb
+- spec/support/client_model.rb
+- spec/support/schema.rb
 homepage: https://github.com/fernandors87/normatron
 licenses: []
 post_install_message: 
@@ -105,8 +107,9 @@ signing_key:
 specification_version: 3
 summary: Normalize attributes for ActiveRecord objects.
 test_files:
-- spec/support/test_model.rb
-- spec/support/schema.rb
-- spec/active_record_spec.rb
-- spec/filters_spec.rb
+- spec/lib/normatron/configuration_spec.rb
+- spec/lib/normatron/extensions/active_record_spec.rb
+- spec/lib/normatron_spec.rb
 - spec/spec_helper.rb
+- spec/support/client_model.rb
+- spec/support/schema.rb

data/README.rdoc

@@ -1,197 +0,0 @@
-= Normatron
-
-Normatron is an attribute normalizer for Ruby On Rails ActiveRecord objects.
-With it you can convert 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 the normalizations.
-
-= Installation
-Let the bundler install the gem by adding the following into your application gemfile:
-  gem 'normatron'
-
-And then bundle it up:
-  $ bundle install
-
-Or install it by yourself:
-  $ gem install normatron
-
-= The problem
-Suppose you have a product model as the following:
-  # ./db/migrate/20120101010000_create_products.rb
-  class CreateProducts < ActiveRecord::Migration
-    def change
-      create_table :products do |t|
-        t.string  :name
-        t.decimal :price, :precision => 10, :scale => 2
-      end
-    end
-  end
-
-  # ./app/models/products.rb
-  class Product < ActiveRecord::Base
-    attr_accessible :name, :price
-  end
-
-And you want the 'name' attribute be uppercased before saving it into the database.
-The most usual approach to do it 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.
-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:
-
-= Usage
-  # ./app/models/products.rb
-  class Product < ActiveRecord::Base
-    attr_accessible :name, :price
-
-    normalize :name, :with => :upcase
-  end
-
-  $ rails console
-  > p = Product.create :name => "  memory   card    "
-  > p.name
-  => "  MEMORY   CARD    "
-
-You can also assign multiple attributes to the same filter:
-  normalize :name, :brand, :with => :capitalize
-
-And multiple filters to an unique attribute:
-  normalize :email, :with => [:downcase, :squish]
-
-Or mixing both:
-  normalize :name, :description, :with => [:upcase, :squish, :blank]
-
-= Filters
-== :upcase and :downcase
-Change all character to upcase and downcase, respectively.
-Accented characters are affected too.
-
-  class User < ActiveRecord::Base
-    attr_accessible :name
-
-    normalize :name, :with => :upcase
-  end
-
-  $ rails console
-  > d = User.create :name => "Darth Vader"
-  > d.name
-  => "DARTH VADER"
-  > j = User.create :name => " José    Negrão  "
-  > j.name
-  => " JOSÉ    NEGRÃO  "
-
-== :capitalize
-Capitalize the first character of the sequence.
-Accented characters are affected too.
-
-  class Player < ActiveRecord::Base
-    attr_accessible :name, :race
-
-    normalize :name, :race, :with => :capitalize
-  end
-
-  $ rails console
-  > a = Player.create :name => "ÉBANO PEREIRA", :race => " protoss"
-  > a.name
-  => "Ébano pereira"
-  > a.race
-  => " protoss"
-
-== :titlecase or :titleize
-Capitalize the first character of each word.
-Accented characters are affected too.
-
-  class Player < ActiveRecord::Base
-    attr_accessible :name, :race
-
-    normalize :name, :race, :with => :titleize
-  end
-
-  $ rails console
-  > a = Player.create :name => "fernando rodrigues", :race => " zerg"
-  > a.name
-  => "Fernando Rodrigues"
-  > a.race
-  => " Zerg"
-
-== :strip, :lstrip and :rstrip
-Remove trailing and/or leading spaces.
-
-  class Address < ActiveRecord::Base
-    attr_accessible :city, :district, :street
-
-    normalize :city, :with => :strip
-    normalize :district, :with => :lstrip
-    normalize :street, :with => :rstrip
-  end
-
-  $ rails console
-  > a = Address.create :city => " gotham ", :district => " red light ", :street => " no name "
-  > a.city
-  => "gotham"
-  > a.district
-  => "red light "
-  > a.street
-  => " no name"
-
-== :squish
-Remove trailing and leading spaces and then changing remaining consecutive whitespace groups into one space each.
-
-  class Product < ActiveRecord::Base
-    attr_accessible :description
-
-    normalize :description, :with => :squish
-  end
-
-  $ rails console
-  > p = Product.create :description => "   \t My   product is \n cheap!  !    !     "
-  > p.description
-  => "My product is cheap!!!"
-
-== :blank
-Convert a blank attribute into nil.
-
-  class Person < ActiveRecord::Base
-    attr_accessible :gender, :name
-
-    normalize :gender, :with => :blank
-  end
-
-  $ rails console
-  > p = Person.create :gender => "     ", :name => "  "
-  > p.gender
-  => nil
-  > p.name
-  => "  "
-
-= Contributing
-* Fork it, add your new features or bug fixes, make your tests and commit.
-* Report any bug or unexpected behavior.
-* Send me your feedback.
-* Pay me a beer. =]
-
-= Special Thanks
-This gem was inspired on work of {fnando}[https://github.com/fnando] called {normalize_attributes}[https://github.com/fnando/normalize_attributes].
-I just forked his gem and added some functionalities.<br>
-He has a lot of interesting gems on his repo, please take a look.
-
-= Licence
-Copyright 2012 Fernando Rodrigues da Silva
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/normatron/active_record.rb

@@ -1,55 +0,0 @@
-require "normatron/filters"
-require "active_record"
-
-module Normatron
-  module ActiveRecord
-    def self.included(base)
-      base.instance_eval do
-        before_validation :apply_normalization
-
-        class << self
-          attr_accessor :normalization_filters
-
-          def normalize(*args)
-            options = args.extract_options!
-            options[:with] ||= [:blank, :squish]
-
-            filters = [options[:with]].flatten.compact
-            filters.map!(&:to_sym)
-            intersect = filters & (Filters.filter_names + methods(false))
-
-            unless intersect == filters
-              raise "Normalization filters #{filters - intersect} doesn't exist"
-            end
-
-            @normalization_filters ||= {}
-            args.each do |raw_attribute|
-              attribute = raw_attribute.to_sym
-
-              if self.column_names.include? attribute.to_s
-                @normalization_filters[attribute] ||= []
-                @normalization_filters[attribute] += filters
-              else
-                raise "Attribute '#{attribute}' doesn't exist in #{self}"
-              end
-            end
-          end
-        end
-      end
-    end
-    
-    def apply_normalization
-      return unless self.class.normalization_filters.is_a? Hash
-
-      self.class.normalization_filters.each do |attribute, filters|
-        value = send("#{attribute}_before_type_cast")  || send(attribute)
-
-        filters.each do |filter|
-          value = Filters.apply(filter, value)
-        end
-
-        write_attribute attribute, value
-      end
-    end
-  end
-end

data/lib/normatron/filters.rb

@@ -1,71 +0,0 @@
-require "active_support/all"
-
-module Normatron
-  module Filters
-    class << self
-      def apply(filter, value)
-        return value unless value.is_a? String
-
-        case filter
-        when :upcase, :downcase, :capitalize, :titlecase, :titleize
-          value.mb_chars.send(filter).to_s
-        when :squish, :lstrip, :rstrip, :strip
-          value.send(filter)
-        when :blank
-          send("to_#{filter}", value)
-        end
-      end
-
-      def filter_names
-        [:upcase, :downcase, :capitalize, :titlecase, :titleize, :squish, :lstrip, :rstrip, :strip, :blank]
-      end
-
-      private
-
-      def to_blank(value)
-        value.blank? ? nil : value
-      end
-    end
-
-=begin
-    def self.filter_currency(value)
-      filter_number value, :currency
-    end
-
-    def self.filter_float(value)
-      filter_number value, :float
-    end
-
-    def self.filter_integer(value)
-      filter_number value
-    end
-
-    def self.filter_number(value, type = :integer)
-      return value unless value.is_a?(String) && value.present?
-
-      # Find the first number in the sequence
-      first_number_position = value.index(/\d/)
-      return unless first_number_position # Do nothing if it's don't have any number
-
-      # Is a negative number?
-      negative = value[0..first_number_position].include?("-")
-
-      # Decimal separator on the current locale
-      separator = I18n.t "number#{ '.currency' if type == :currency }.format.separator"
-
-      # Amount of decimal places
-      separator_position = value.rindex(separator)
-      chars_until_separator = separator_position + 1 rescue value.size
-      decimal_places = value.size - chars_until_separator
-
-      # Build number
-      res = filter_digits(value).to_f
-      res *= -1 if negative
-      res /= 10 ** decimal_places
-      res = res.to_i if type == :integer
-
-      res
-    end
-=end
-  end
-end

data/spec/active_record_spec.rb

@@ -1,137 +0,0 @@
-require "spec_helper"
-
-describe Normatron::ActiveRecord do
-  before :each do
-    TestModel.normalization_filters = nil
-  end
-
-  it "filters should be accessible" do
-    TestModel.normalize :string_column, :with => [:capitalize, :upcase]
-    TestModel.normalize :integer_column, :with => :blank
-    TestModel.normalization_filters.should == { :string_column => [:capitalize, :upcase],
-                                                :integer_column => [:blank] }
-    TestModel.normalization_filters.delete :string_column
-    TestModel.normalization_filters.should == { :integer_column => [:blank] }
-  end
-
-  it "should save without normalization" do
-    lambda do
-      instance = TestModel.new :string_column => "Any string"
-      instance.save!
-    end.should_not raise_error
-  end
-
-  it "should skip normalization when filters aren't a Hash" do
-    TestModel.normalization_filters = true
-    lambda do
-      instance = TestModel.new :string_column => "Any string"
-      instance.valid?
-    end.should_not raise_error
-
-    TestModel.normalization_filters = 1
-    lambda do
-      instance = TestModel.new :string_column => "Any string"
-      instance.valid?
-    end.should_not raise_error
-
-    TestModel.normalization_filters = false
-    lambda do
-      instance = TestModel.new :string_column => "Any string"
-      instance.valid?
-    end.should_not raise_error
-  end
-
-  it "should apply default filter to single attribute" do
-    TestModel.normalize :string_column
-    TestModel.normalization_filters.should == { :string_column => [:blank, :squish] }
-  end
-
-  it "should apply default filter to multiple attributes" do
-    TestModel.normalize :string_column, :integer_column
-    TestModel.normalization_filters.should == { :string_column => [:blank, :squish],
-                                                :integer_column => [:blank, :squish] }
-  end
-
-  it "should apply single filter to single attribute" do
-    TestModel.normalize :string_column, :with => :upcase
-    TestModel.normalization_filters.should == { :string_column => [:upcase] }
-  end
-
-  it "should apply single filter to multiple attributes" do
-    TestModel.normalize :string_column, :integer_column, :with => :blank
-    TestModel.normalization_filters.should == { :string_column => [:blank],
-                                                :integer_column => [:blank] }
-  end
-
-  it "should apply multiple filters to single attribute" do
-    TestModel.normalize :string_column, :with => [:blank, :upcase]
-    TestModel.normalization_filters.should == { :string_column => [:blank, :upcase] }
-  end
-
-  it "should apply multiple filters to multiple attributes" do
-    TestModel.normalize :string_column, :integer_column, :with => [:squish, :blank]
-    TestModel.normalization_filters.should == { :string_column => [:squish, :blank],
-                                                :integer_column => [:squish, :blank] }
-  end
-
-  it "should stack filters for the same attribute" do
-    TestModel.normalize :string_column, :with => [:upcase, :squish]
-    TestModel.normalize :string_column, :integer_column, :with => :blank
-    TestModel.normalize :string_column, :integer_column, :with => [:downcase, :strip]
-    TestModel.normalization_filters.should == { :string_column  => [:upcase, :squish, :blank, :downcase, :strip],
-                                                :integer_column => [:blank, :downcase, :strip] }
-  end
-
-  it "should apply attributes as string" do
-    TestModel.normalize "string_column", :with => :upcase
-
-    instance = TestModel.new :string_column => "Any string"
-    instance.valid?
-    instance.string_column.should == "ANY STRING"
-
-    TestModel.normalization_filters.should == { :string_column  => [:upcase] }
-  end
-
-  it "should apply filters as one word string" do
-    TestModel.normalize :string_column, :with => "upcase"
-
-    TestModel.normalization_filters.should == { :string_column  => [:upcase] }
-
-    instance = TestModel.new :string_column => "Any string"
-    instance.valid?
-    instance.string_column.should == "ANY STRING"
-  end
-
-  it "should raise error when a wrong filter is used" do
-    lambda do
-      TestModel.normalize :string_column, :with => :wrong_filter
-    end.should raise_error "Normalization filters [:wrong_filter] doesn't exist"
-  end
-
-  it "should raise error when a wrong attribute is used" do
-    lambda do
-      TestModel.normalize :wrong_column, :with => :upcase
-    end.should raise_error "Attribute 'wrong_column' doesn't exist in TestModel"
-  end
-
-  pending "should allow use an instance method as a filter" do
-    lambda do
-      TestModel.normalize :string_column, :with => :my_custom_filter_method
-    end.should_not raise_error "Normalization filters [:my_custom_filter_method] doesn't exist"
-
-    TestModel.normalization_filters.should == { :string_column  => [:my_custom_filter_method] }
-  end
-
-  pending "should apply an instance method used as a filter" do
-    TestModel.normalize :string_column, :with => :my_custom_filter_method
-
-    m = TestModel.new :string_column => "My life for Aiur"
-    m.string_column.should == "M-y- -l-i-f-e- -f-o-r- -A-i-u-r"
-  end
-
-  pending "should allow change default callback"
-  pending "should allow get value after type cast"
-  pending "should allow use blocks"
-  pending "should allow build custom filters"
-  pending "should allow use a instance method as a filter"
-end

data/spec/filters_spec.rb

@@ -1,218 +0,0 @@
-# encoding: utf-8
-
-require "spec_helper"
-
-describe Normatron::Filters do
-
-  before :each do
-    TestModel.normalization_filters = nil
-  end
-
-  it :blank do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:blank, value).should == expected
-
-    value     = "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    expected  = "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    Normatron::Filters.apply(:blank, value).should == expected
-
-    value     = "      "
-    expected  = nil
-    Normatron::Filters.apply(:blank, value).should == expected
-
-    value     = ""
-    expected  = nil
-    Normatron::Filters.apply(:blank, value).should == expected
-  end
-
-  it :capitalize do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:capitalize, value).should == expected
-
-    value     = "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    expected  = "   abc   \f   def   \n   123   áèç   \t !*&   \r   4gü   "
-    Normatron::Filters.apply(:capitalize, value).should == expected
-
-    value     = "abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü"
-    expected  = "Abc   \f   def   \n   123   áèç   \t !*&   \r   4gü"
-    Normatron::Filters.apply(:capitalize, value).should == expected
-  end
-
-  it :downcase do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:downcase, value).should == expected
-
-    value     = "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    expected  = "   abc   \f   def   \n   123   áèç   \t !*&   \r   4gü   "
-    Normatron::Filters.apply(:downcase, value).should == expected
-  end
-
-  it :lstrip do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:lstrip, value).should == expected
-
-    value     = "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    expected  = "abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    Normatron::Filters.apply(:lstrip, value).should == expected
-  end
-
-  it :rstrip do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:rstrip, value).should == expected
-
-    value     = "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    expected  = "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü"
-    Normatron::Filters.apply(:rstrip, value).should == expected
-  end
-
-  it :squish do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:squish, value).should == expected
-
-    value     = "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    expected  = "abc DEF 123 áÈç !*& 4gü"
-    Normatron::Filters.apply(:squish, value).should == expected
-  end
-
-  it :strip do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:strip, value).should == expected
-
-    value     = "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    expected  = "abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü"
-    Normatron::Filters.apply(:strip, value).should == expected
-  end
-
-  it :titlecase do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:titlecase, value).should == expected
-    Normatron::Filters.apply(:titleize, value).should == expected
-
-    value     = "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    expected  = "   Abc   \f   Def   \n   123   Áèç   \t !*&   \r   4gü   "
-    Normatron::Filters.apply(:titlecase, value).should == expected
-    Normatron::Filters.apply(:titleize, value).should == expected
-  end
-
-  it :upcase do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:upcase, value).should == expected
-
-    value     = "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    expected  = "   ABC   \f   DEF   \n   123   ÁÈÇ   \t !*&   \r   4GÜ   "
-    Normatron::Filters.apply(:upcase, value).should == expected
-  end
-
-  pending "singularize"
-  pending "pluralize"
-  pending "parameterize"
-  pending "humanize"
-  pending "upper_camelcase"
-  pending "lower_camelcase"
-  pending "classify"
-  pending "dasherize"
-  pending "deconstantize"
-  pending "demodulize"
-  pending "html_safe"
-  pending "constantize"
-  pending "tableize"
-  pending "underscore"
-=begin
-  it :singularize do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:singularize, value).should == expected
-
-    value     = "products"
-    expected  = "product"
-    Normatron::Filters.apply(:singularize, value).should == expected
-  end
-
-  it :pluralize do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:pluralize, value).should == expected
-
-    value     = "product"
-    expected  = "products"
-    Normatron::Filters.apply(:pluralize, value).should == expected
-  end
-
-  it :parameterize do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:parameterize, value).should == expected
-
-    value     = "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    expected  = "abc-def-123-aec-4gu"
-    Normatron::Filters.apply(:parameterize, value).should == expected
-  end
-
-  it :humanize do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:humanize, value).should == expected
-
-    value     = "éou_shall_not_pass"
-    expected  = "Éou_shall_not_pass"
-    Normatron::Filters.apply(:humanize, value).should == expected
-  end
-
-  it :upper_camelcase do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:camelize, value).should == expected
-    Normatron::Filters.apply(:camelcase, value).should == expected
-    Normatron::Filters.apply(:upper_camelize, value).should == expected
-    Normatron::Filters.apply(:upper_camelcase, value).should == expected
-
-    value     = "active_record/érrors"
-    expected  = "ActiveRecord::Érrors"
-    Normatron::Filters.apply(:camelize, value).should == expected
-    Normatron::Filters.apply(:camelcase, value).should == expected
-    Normatron::Filters.apply(:upper_camelize, value).should == expected
-    Normatron::Filters.apply(:upper_camelcase, value).should == expected
-  end
-
-  it :lower_camelcase do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:lower_camelize, value).should == expected
-    Normatron::Filters.apply(:lower_camelcase, value).should == expected
-
-    value     = "active_record/érrors"
-    expected  = "activeRecord::Érrors"
-    Normatron::Filters.apply(:lower_camelize, value).should == expected
-    Normatron::Filters.apply(:lower_camelcase, value).should == expected
-  end
-
-  it :classify do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:classify, value).should == expected
-
-    value     = "áctive_record/errors"
-    expected  = "ÁctiveRecord::Errors"
-    Normatron::Filters.apply(:classify, value).should == expected
-  end
-
-  it :dasherize do
-    value     = nil
-    expected  = nil
-    Normatron::Filters.apply(:dasherize, value).should == expected
-
-    value     = "active_record/errors"
-    expected  = "active-record/errors"
-    Normatron::Filters.apply(:dasherize, value).should == expected
-  end
-=end
-end

data/spec/support/test_model.rb

@@ -1,7 +0,0 @@
-class TestModel < ActiveRecord::Base
-  attr_accessible :string_column, :integer_column
-
-  def my_custom_filter_method(value)
-    value.split(//) * "-"
-  end
-end