normatron 0.0.5 → 0.0.6

data/MIT-LICENSE

@@ -17,4 +17,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -1,29 +1,22 @@
 = Normatron
 
-Normatron is a attribute normalizer for ActiveRecord.
+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 normalization.
+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
-
-I have a product model as the following:
-
+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|
@@ -34,47 +27,19 @@ I have a product model as the following:
   end
 
   # ./app/models/products.rb
-
   class Product < ActiveRecord::Base
     attr_accessible :name, :price
   end
 
-And I want the product name to be uppercased before save.
-I can do it basically by two ways:
-
-== a. Overriding the 'name' method
-
-  # ./app/models/products.rb
-
-  class Product < ActiveRecord::Base
-    attr_accessible :name, :price
-
-    def name=(value)
-      super value.mb_chars.upcase
-    end
-  end
-
-== b. Using the before_validation callback
-
-  # ./app/models/products.rb
-
-  class Product < ActiveRecord::Base
-    attr_accessible :name, :price
-
-    before_validation :do_upcase
-
-    def do_upcase
-      write_attribute :name, name.mb_chars.upcase
-    end
-  end
-
-Both ways are ilenegant, boring, error prone and expensive.
-Which led me to use a third method:
+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
 
@@ -86,41 +51,14 @@ Which led me to use a third method:
   > p.name
   => "  MEMORY   CARD    "
 
-You can assign multiple attributes to the same filter:
-
-  # ./app/models/products.rb
-
-  class Product < ActiveRecord::Base
-    attr_accessible :name, :description, :brand, :price
-
-    normalize :name, :brand, :with => :capitalize
-  end
-
-  $ rails console
-  > p = Product.create :name => "memory   card    4  GB    ", :brand => "OEM"
-  > p.name
-  => "Memory   card    4  GB    "
-  > p.brand
-  => "Oem"
-
-And/or assign multiple filters to multiple attributes:
-
-  # ./app/models/products.rb
-
-  class Product < ActiveRecord::Base
-    attr_accessible :name, :description, :brand, :price
+You can also assign multiple attributes to the same filter:
+  normalize :name, :brand, :with => :capitalize
 
-    normalize :name, :description, :brand, :with => [:upcase, :squish, :nillify]
-  end
+And multiple filters to an unique attribute:
+  normalize :email, :with => [:downcase, :squish]
 
-  $ rails console
-  > p = Product.create :name => "   memory   card    4  GB    ", :description => "         ", :brand => "oem   "
-  > p.name
-  => "MEMORY CARD 4 GB"
-  > p.brand
-  => "OEM"
-  > p.description
-  => nil
+Or mixing both:
+  normalize :name, :description, :with => [:upcase, :squish, :blank]
 
 = Filters
 == :upcase and :downcase
@@ -209,13 +147,13 @@ Remove trailing and leading spaces and then changing remaining consecutive white
   > p.description
   => "My product is cheap!!!"
 
-== :nillify, :nullify or :nil
+== :blank
 Convert a blank attribute into nil.
 
   class Person < ActiveRecord::Base
     attr_accessible :gender, :name
 
-    normalize :gender, :with => :nil
+    normalize :gender, :with => :blank
   end
 
   $ rails console
@@ -225,7 +163,35 @@ Convert a blank attribute into 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.
-He has a lot of interesting gems on his repo, please take a look.
+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/Rakefile

@@ -31,5 +31,4 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
-
-task :default => :test
+task :default => :test

data/lib/normatron.rb

@@ -1,4 +1,7 @@
-require "normatron/filters"
 require "normatron/active_record"
 
+module Normatron
+  VERSION = "0.0.6"
+end
+
 ActiveRecord::Base.send :include, Normatron::ActiveRecord

data/lib/normatron/active_record.rb

@@ -1,76 +1,51 @@
+require "normatron/filters"
 require "active_record"
 
 module Normatron
   module ActiveRecord
-
     def self.included(base)
       base.instance_eval do
-        extend ClassMethods
-
-        before_validation :normalize_attributes
+        before_validation :apply_normalization
 
         class << self
-          attr_accessor :normalization_options
-        end
-      end
-    end
-
-    module ClassMethods
-
-      def normalize(*args)
-        # Extract options
-        @normalization_options ||= {}
-        options = args.extract_options!
-
-        # Set callbacks
-        filters = []
-        if options.empty? # Default standardization
-          filters << [:squish, :nillify]
-        elsif options.has_key? :with
-          filters << options[:with]
-        else
-          raise "Wrong normalization key in #{self.name}, use :with instead of #{options.keys.first}"
-        end
-
-        # Make a prettier array
-        filters = filters.flatten.compact
-        filters.map! { |v| v = v.to_sym }
-
-        # Check filters
-        filters.each do |f|
-          unless Filters::NAMES.include? f
-            raise "Normalization filter '#{f}' doesn't exist"
+          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
-
-        # Add normalization callbacks
-        args.each do |attribute|
-          # Check attributes
-          unless self.column_names.include? attribute.to_s
-            raise "Attribute '#{attribute}' doesn't exist in #{self.name}"
-          end
-
-          @normalization_options[attribute] ||= []
-          @normalization_options[attribute] += filters
-        end
       end
-      alias :normatron :normalize
     end
+    
+    def apply_normalization
+      return unless self.class.normalization_filters.is_a? Hash
 
-    def normalize_attributes
-      options = self.class.normalization_options
-      return unless options
-
-      options.each do |attribute, methods|
+      self.class.normalization_filters.each do |attribute, filters|
         value = send("#{attribute}_before_type_cast")  || send(attribute)
 
-        methods.each do |method|
-          value = Filters.do_filter(method, value) unless value.nil?
-
-          if value == :no_method
-            raise ArgumentError, "Method :#{method} cannot be resolved.
-             Check options for #{attribute} in #{klass}", caller
-          end
+        filters.each do |filter|
+          value = Filters.apply(filter, value)
         end
 
         write_attribute attribute, value

data/lib/normatron/filters.rb

@@ -1,42 +1,33 @@
-require "i18n"
 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
 
-    private
-
-    MB_CHARS_METHODS = [:upcase, :downcase, :capitalize, :lstrip, :rstrip, :strip, :titlecase, :titleize]
-    SELF_METHODS = [:nillify, :nullify, :nil, :squish, :currency, :integer, :float]
-
-    public
-
-    NAMES = MB_CHARS_METHODS + SELF_METHODS
-
-    def self.do_filter(method, value)
-      if MB_CHARS_METHODS.include? method
-        value.mb_chars.send(method).to_s
-      elsif SELF_METHODS.include? method
-        send("filter_#{method}", value)
-      else
-        :no_method
+      def filter_names
+        [:upcase, :downcase, :capitalize, :titlecase, :titleize, :squish, :lstrip, :rstrip, :strip, :blank]
       end
-    end
 
-    # Return nil if value is blank or else value itself.
-    def self.filter_nillify(value)
-      value.blank? ? nil : value
-    end
-    class << self
-      alias :filter_nil      :filter_nillify
-      alias :filter_nullify  :filter_nillify
-    end
+      private
 
-    # Remove repeated spaces from the string.
-    def self.filter_squish(value)
-      value.squish
+      def to_blank(value)
+        value.blank? ? nil : value
+      end
     end
 
+=begin
     def self.filter_currency(value)
       filter_number value, :currency
     end
@@ -75,5 +66,6 @@ module Normatron
 
       res
     end
+=end
   end
 end

data/spec/active_record_spec.rb

@@ -0,0 +1,137 @@
+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

@@ -5,73 +5,214 @@ require "spec_helper"
 describe Normatron::Filters do
 
   before :each do
-    TestModel.normalization_options = nil
+    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
-    TestModel.normalize :string_column, :with => :capitalize
+    value     = nil
+    expected  = nil
+    Normatron::Filters.apply(:capitalize, value).should == expected
 
-    m = TestModel.create :string_column => "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    m.string_column.should == "   abc   \f   def   \n   123   áèç   \t !*&   \r   4gü   "
+    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
 
-    m.string_column = "abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü"
-    m.valid?
-    m.string_column.should == "Abc   \f   def   \n   123   áèç   \t !*&   \r   4gü"
+    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
-    TestModel.normalize :string_column, :with => :downcase
+    value     = nil
+    expected  = nil
+    Normatron::Filters.apply(:downcase, value).should == expected
 
-    m = TestModel.create :string_column => "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    m.string_column.should == "   abc   \f   def   \n   123   áèç   \t !*&   \r   4gü   "
+    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
-    TestModel.normalize :string_column, :with => :squish
+    value     = nil
+    expected  = nil
+    Normatron::Filters.apply(:squish, value).should == expected
 
-    m = TestModel.create :string_column => "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    m.string_column.should == "abc DEF 123 áÈç !*& 4gü"
+    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
-    TestModel.normalize :string_column, :with => :strip
+    value     = nil
+    expected  = nil
+    Normatron::Filters.apply(:strip, value).should == expected
 
-    m = TestModel.create :string_column => "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    m.string_column.should == "abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü"
+    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
-    TestModel.normalize :string_column, :with => :titlecase
-
-    m = TestModel.create :string_column => "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    m.string_column.should == "   Abc   \f   Def   \n   123   Áèç   \t !*&   \r   4gü   "
+    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
-    TestModel.normalize :string_column, :with => :upcase
+    value     = nil
+    expected  = nil
+    Normatron::Filters.apply(:upcase, value).should == expected
 
-    m = TestModel.create :string_column => "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    m.string_column.should == "   ABC   \f   DEF   \n   123   ÁÈÇ   \t !*&   \r   4GÜ   "
+    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
 
-  it :nillify do
-    TestModel.normalize :string_column, :with => :nillify
+  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
 
-    m = TestModel.create :string_column => "               "
-    m.string_column.should == nil
+  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 :lstrip do
-    TestModel.normalize :string_column, :with => :lstrip
+  it :parameterize do
+    value     = nil
+    expected  = nil
+    Normatron::Filters.apply(:parameterize, value).should == expected
 
-    m = TestModel.create :string_column => "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    m.string_column.should == "abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
+    value     = "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
+    expected  = "abc-def-123-aec-4gu"
+    Normatron::Filters.apply(:parameterize, value).should == expected
   end
 
-  it :rstrip do
-    TestModel.normalize :string_column, :with => :rstrip
+  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
 
-    m = TestModel.create :string_column => "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü   "
-    m.string_column.should == "   abc   \f   DEF   \n   123   áÈç   \t !*&   \r   4gü"
+    value     = "active_record/errors"
+    expected  = "active-record/errors"
+    Normatron::Filters.apply(:dasherize, value).should == expected
   end
+=end
 end

data/spec/spec_helper.rb

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

data/spec/support/test_model.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: normatron
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-30 00:00:00.000000000 Z
+date: 2012-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -34,7 +34,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -50,7 +50,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.10.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,26 +58,26 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.0.0
-description: ! "    Normatron is a Rails plugin that helps normalize ActiveRecord
-  attributes.\n    Operations such as lowercase an e-mail address or format a phone
-  number before model validations,\n    can be made easily using this plugin.\n"
+        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 the normalizations.\n"
 email:
-- fernandors87@hotmail.com
+- fernandors87@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/normatron/filters.rb
 - lib/normatron/active_record.rb
-- lib/normatron/version.rb
 - lib/normatron.rb
 - MIT-LICENSE
 - Rakefile
 - README.rdoc
 - spec/support/test_model.rb
-- spec/normatron_spec.rb
-- spec/schema.rb
+- spec/support/schema.rb
+- spec/active_record_spec.rb
 - spec/filters_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/fernandors87/normatron
@@ -103,10 +103,10 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Handle normalization for ActiveRecord attributes
+summary: Normalize attributes for ActiveRecord objects.
 test_files:
 - spec/support/test_model.rb
-- spec/normatron_spec.rb
-- spec/schema.rb
+- spec/support/schema.rb
+- spec/active_record_spec.rb
 - spec/filters_spec.rb
 - spec/spec_helper.rb

data/lib/normatron/version.rb

@@ -1,3 +0,0 @@
-module Normatron
-  VERSION = "0.0.5"
-end

data/spec/normatron_spec.rb

@@ -1,86 +0,0 @@
-# encoding: utf-8
-
-require "spec_helper"
-
-describe Normatron do
-  before :each do
-    TestModel.normalization_options = nil
-  end
-
-  it "should respond to aliases" do
-    TestModel.should respond_to :normatron
-  end
-
-  it "should save without normalization option" do
-    lambda do
-      instance = TestModel.new
-      instance.string_column = "Any string"
-      instance.save!
-    end.should_not raise_error
-  end
-
-  it "filters should be accessible" do
-    TestModel.normalize :string_column, :with => [:capitalize, :upcase]
-    TestModel.normalize :integer_column, :with => :integer
-    TestModel.normalization_options.should == { :string_column => [:capitalize, :upcase], :integer_column => [:integer] }
-    TestModel.normalization_options.delete :string_column
-    TestModel.normalization_options.should == { :integer_column => [:integer] }
-  end
-
-  it "should apply single filter" do
-    TestModel.normalize :string_column, :with => :upcase
-
-    m = TestModel.create :string_column => "master of puppets"
-    m.string_column.should == "MASTER OF PUPPETS"
-  end
-
-  it "should apply multiple filters" do
-    TestModel.normalize :string_column, :with => [:downcase, :squish, :nil]
-
-    m = TestModel.create :string_column => "     YOU   SHALL    NOT   PASS    "
-    m.string_column.should == "you shall not pass"
-
-    m = TestModel.create :string_column => "     "
-    m.string_column.should == nil
-  end
-
-  it "should stack filters for the same attribute" do
-    TestModel.normalize :string_column, :with => [:upcase, :squish]
-    TestModel.normalize :string_column, :with => :nil
-    TestModel.normalization_options.should == { :string_column => [:upcase, :squish, :nil] }
-  end
-
-  it "default filters should be :squish and :nillify" do
-    TestModel.normalize :string_column
-    TestModel.normalization_options.should == { :string_column => [:squish, :nillify] }
-  end
-
-   it "default filters should be :squish and :nillify" do
-    TestModel.normalize :string_column
-    TestModel.normalization_options.should == { :string_column => [:squish, :nillify] }
-  end
-
-  it "should filter multiple attributes" do
-    TestModel.normalize :string_column, :integer_column, :with => :nil
-
-    m = TestModel.create :string_column => "      ", :integer_column => "      "
-    m.string_column.should == nil
-    m.integer_column.should == nil
-  end
-
-  it "should raise error if a wrong option is set and the right isn't" do
-    lambda do
-      TestModel.normalize :string_column, :wrong_option => :upcase
-    end.should raise_error "Wrong normalization key in TestModel, use :with instead of wrong_option"
-
-    lambda do
-      TestModel.normalize :string_column, :wrong_option => :upcase, :with => :downcase
-    end.should_not raise_error
-  end
-
-  it "should raise error if wrong filter is called" do
-    lambda do
-      TestModel.normalize :string_column, :with => :wrong_filter
-    end.should raise_error "Normalization filter 'wrong_filter' doesn't exist"
-  end
-end