normatron 0.0.3 → 0.0.4

data/README.rdoc

@@ -1,3 +1,31 @@
 = Normatron
 
-This project rocks and uses MIT-LICENSE.
+Normatron is a attribute normalizer for ActiveRecord.
+
+= Installation
+
+Add the following into your gemfile:
+
+  gem 'normatron'
+
+Bundle it up:
+  
+  $ bundle install
+
+= Usage
+
+Let's take an example model:
+
+app/models/product.rb
+  class Product < ActiveRecord::Base
+    attr_accessible :name
+
+    normalize :name, :with => :upcase
+  end
+
+  $ rails console
+  > p = Product.new
+  > p.name = "  memory   card    "
+  > p.valid?
+  > p.name
+  => "  MEMORY   CARD    "

data/lib/normatron/active_record.rb

@@ -2,7 +2,6 @@ require "active_record"
 
 module Normatron
   module ActiveRecord
-    include Conversors
 
     def self.included(base)
       base.instance_eval do
@@ -11,39 +10,63 @@ module Normatron
         before_validation :normalize_attributes
 
         class << self
-          attr_accessor :standardize_options
+          attr_accessor :normalization_options
         end
       end
     end
 
     module ClassMethods
+      # Set an attribute normalization before model validation.
+      # Args uses the attribute names following by a hash with conversion options.
+      #
+      # Example 1:
+      # normalize :attribute_name
+      # 
+      # Example 2:
+      # normalize :attribute_name, :with => :upcase
+      #
+      # Example 3:
+      # normalize :attribute_name, :with => [:squish, :downcase]
       def normalize(*args)
         # Extract options
-        self.standardize_options ||= {}
+        @normalization_options ||= {}
         options = args.extract_options!
 
-        methods = []
+        # Set conversors
+        conversors = []
         if options.empty? # Default standardization
-          methods << [:trim, :strip, :nillify]
+          conversors << [:squish, :strip, :nillify]
         elsif options.has_key? :with
-          methods << options[:with]
+          conversors << options[:with]
         else
-          raise "Wrong normalization option in #{self.name}, use :with instead."
+          raise "Wrong normalization key in #{self.name}, use :with instead of #{options.keys.first}"
         end
 
         # Make a prettier array
-        methods = methods.flatten.compact
-        methods.map! { |v| v = v.to_sym }
+        conversors = conversors.flatten.compact
+        conversors.map! { |v| v = v.to_sym }
 
-        # Add normalization methods to call
+        # Check conversors
+        conversors.each do |c|
+          unless Conversors::CALLBACKS.include? c
+            raise "Normalization callback '#{c}' doesn't exist"
+          end
+        end
+
+        # Add normalization conversors
         args.each do |attribute|
-          standardize_options[attribute] = methods
+          # Check attributes
+          unless self.column_names.include? attribute.to_s
+            raise "Attribute '#{attribute}' doesn't exist in #{self.name}"
+          end
+
+          @normalization_options[attribute] = conversors
         end
       end
     end
 
     def normalize_attributes
-      options = self.class.standardize_options
+      options = self.class.normalization_options
       return unless options
 
       options.each do |attribute, methods|
@@ -51,7 +74,8 @@ module Normatron
 
         methods.each do |method|
           # Skip if value is nil originally or the method 'nullify' was called before
-          value = convert(method, value) unless value.nil?
+          value = Conversors.convert(method, value) unless value.nil?
+
           if value == :no_method
             raise ArgumentError, "Method :#{method} cannot be resolved.
              Check options for #{attribute} in #{klass}", caller

data/lib/normatron/conversors.rb

@@ -4,46 +4,47 @@ require "active_support/all"
 module Normatron
   module Conversors
 
-    @@MB_CHARS_METHODS = [:upcase, :downcase, :capitalize, :lstrip, :rstrip, :strip, :titlecase, :titleize]
-    @@SELF_METHODS = [:nillify, :nullify, :nil, :squish, :currency, :integer, :float, :postal_code, :phone, :digits, :phrase]
+    MB_CHARS_METHODS = [:upcase, :downcase, :capitalize, :lstrip, :rstrip, :strip, :titlecase, :titleize]
+    SELF_METHODS = [:nillify, :nullify, :nil, :squish, :currency, :integer, :float, :postal_code, :phone, :digits, :phrase]
+    CALLBACKS = MB_CHARS_METHODS + SELF_METHODS
 
-    def convert(method, value)
-      if @@MB_CHARS_METHODS.include? method
+    def self.convert(method, value)
+      if MB_CHARS_METHODS.include? method
         value.mb_chars.send(method).to_s
-      elsif @@SELF_METHODS.include? method
+      elsif SELF_METHODS.include? method
         send("convert_#{method}", value)
       else
         :no_method
       end
     end
 
-    private
-
     # Return nil if value is blank or else value itself.
-    def convert_nillify(value)
+    def self.convert_nillify(value)
       value.blank? ? nil : value
     end
-    alias :convert_nil      :convert_nillify
-    alias :convert_nullify  :convert_nillify
+    class << self
+      alias :convert_nil      :convert_nillify
+      alias :convert_nullify  :convert_nillify
+    end
 
     # Remove repeated spaces from the string.
-    def convert_squish(value)
+    def self.convert_squish(value)
       value.mb_chars.to_s.gsub(/\p{Zs}+/u, ' ')
     end
 
-    def convert_currency(value)
+    def self.convert_currency(value)
       convert_number value, :currency
     end
 
-    def convert_float(value)
+    def self.convert_float(value)
       convert_number value, :float
     end
 
-    def convert_integer(value)
+    def self.convert_integer(value)
       convert_number value
     end
 
-    def convert_number(value, type = :integer)
+    def self.convert_number(value, type = :integer)
       return value unless value.is_a?(String) && value.present?
 
       # Find the first number in the sequence
@@ -70,21 +71,21 @@ module Normatron
       res
     end
 
-    def convert_postal_code(value)
+    def self.convert_postal_code(value)
       res = convert_digits value
       res.size == 8 ? "%s-%s" % [res[0..4], res[5..7]] : value
     end
 
-    def convert_phone(value)
+    def self.convert_phone(value)
       res = convert_digits value
       res.size == 10 ? "(%s) %s-%s" % [res[0..1], res[2..5], res[6..9]] : value
     end
 
-    def convert_digits(value)
+    def self.convert_digits(value)
       value.to_s.gsub(/[^\d]/, '')
     end
 
-    def convert_phrase(value)
+    def self.convert_phrase(value)
       convert(:squish, convert(:strip, value))
     end
   end

data/lib/normatron/version.rb

@@ -1,3 +1,3 @@
 module Normatron
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/normatron_spec.rb

@@ -4,119 +4,145 @@ require "spec_helper"
 
 describe Normatron do
   before :each do
-    TestModel.standardize_options = nil
+    TestModel.normalization_options = nil
+    @instance = TestModel.new
   end
 
-  it "should save without any normalize options" do
+  it "should allow save without any normalize option" do
     lambda do
-      a = TestModel.new
-      a.string_field = "a"
-      a.save!
+      @instance.string_column = "Any string"
+      @instance.save!
     end.should_not raise_error
   end
 
+  it "should raise an error if attribute doesn't exist" do
+    lambda do
+      TestModel.normalize :ghost_attribute
+    end.should raise_error "Attribute 'ghost_attribute' doesn't exist in TestModel"
+  end
+
+  it "should raise an error if a wrong option is set" 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"
+  end
+
+  it "should raise an error if wrong conversor is called" do
+    lambda do
+      TestModel.normalize :string_column, :with => :wrong_conversor
+    end.should raise_error "Normalization callback 'wrong_conversor' doesn't exist"
+  end
+
+  it "options 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
+
   describe "Conversors" do
     it :capitalize do
-      TestModel.normalize :string_field, :with => :capitalize
+      TestModel.normalize :string_column, :with => :capitalize
 
-      m = TestModel.create :string_field => "áb c, 1 2 3 DEF GHI i oz    "
-      m.string_field.should == "Áb c, 1 2 3 def ghi i oz    "
+      m = TestModel.create :string_column => "áb c, 1 2 3 DEF GHI i oz "
+      m.string_column.should == "Áb c, 1 2 3 def ghi i oz "
     end
 
     it :digits do
-      TestModel.normalize :string_field, :with => :digits
+      TestModel.normalize :string_column, :with => :digits
 
-      m = TestModel.create :string_field => " 1a 2b 3c 4d 5e 6f "
-      m.string_field.should == "123456"
+      m = TestModel.create :string_column => " 1a 2b 3c 4d 5e 6f "
+      m.string_column.should == "123456"
     end
 
     it :downcase do
-      TestModel.normalize :string_field, :with => :downcase
+      TestModel.normalize :string_column, :with => :downcase
 
-      m = TestModel.create :string_field => "   a   b c, 1 2 3 DEF GHI i oz    "
-      m.string_field.should == "   a   b c, 1 2 3 def ghi i oz    "
+      m = TestModel.create :string_column => " a b c, 1 2 3 DEF GHI i oz "
+      m.string_column.should == " a b c, 1 2 3 def ghi i oz "
     end
 
     it :phone do
-      TestModel.normalize :string_field, :with => :phone
+      TestModel.normalize :string_column, :with => :phone
 
-      m = TestModel.create :string_field => "(99) 9999-9999"
-      m.string_field.should == "(99) 9999-9999"
+      m = TestModel.create :string_column => "(99) 9999-9999"
+      m.string_column.should == "(99) 9999-9999"
 
-      m = TestModel.create :string_field => "9999999999"
-      m.string_field.should == "(99) 9999-9999"
+      m = TestModel.create :string_column => "9999999999"
+      m.string_column.should == "(99) 9999-9999"
 
-      m = TestModel.create :string_field => "999999999"
-      m.string_field.should == "999999999"
+      m = TestModel.create :string_column => "999999999"
+      m.string_column.should == "999999999"
     end
 
     it :phrase do
-      TestModel.normalize :string_field, :with => :phrase
+      TestModel.normalize :string_column, :with => :phrase
 
-      m = TestModel.create :string_field => "   a   b c, 1 2 3 DEF GHI i oz    "
-      m.string_field.should == "a b c, 1 2 3 DEF GHI i oz"
+      m = TestModel.create :string_column => " a b c, 1 2 3 DEF GHI i oz "
+      m.string_column.should == "a b c, 1 2 3 DEF GHI i oz"
     end
 
     it :postal_code do
-      TestModel.normalize :string_field, :with => :postal_code
+      TestModel.normalize :string_column, :with => :postal_code
 
-      m = TestModel.create :string_field => "88888-888"
-      m.string_field.should == "88888-888"
+      m = TestModel.create :string_column => "88888-888"
+      m.string_column.should == "88888-888"
 
-      m = TestModel.create :string_field => "88888888"
-      m.string_field.should == "88888-888"
+      m = TestModel.create :string_column => "88888888"
+      m.string_column.should == "88888-888"
 
-      m = TestModel.create :string_field => "8888888"
-      m.string_field.should == "8888888"
+      m = TestModel.create :string_column => "8888888"
+      m.string_column.should == "8888888"
     end
 
     it :squish do
-      TestModel.normalize :string_field, :with => :squish
+      TestModel.normalize :string_column, :with => :squish
 
-      m = TestModel.create :string_field => "   a   b c, 1 2 3 DEF GHI i oz    "
-      m.string_field.should == " a b c, 1 2 3 DEF GHI i oz "
+      m = TestModel.create :string_column => " a b c, 1 2 3 DEF GHI i oz "
+      m.string_column.should == " a b c, 1 2 3 DEF GHI i oz "
     end
 
     it :strip do
-      TestModel.normalize :string_field, :with => :strip
+      TestModel.normalize :string_column, :with => :strip
 
-      m = TestModel.create :string_field => "   a   b c, 1 2 3 DEF GHI i oz    "
-      m.string_field.should == "a   b c, 1 2 3 DEF GHI i oz"
+      m = TestModel.create :string_column => " a b c, 1 2 3 DEF GHI i oz "
+      m.string_column.should == "a b c, 1 2 3 DEF GHI i oz"
     end
 
     it :titlecase do
-      TestModel.normalize :string_field, :with => :titlecase
+      TestModel.normalize :string_column, :with => :titlecase
 
-      m = TestModel.create :string_field => "   aé   áb c, 1 2 3 DEF GHI i oz    "
-      m.string_field.should == "   Aé   Áb C, 1 2 3 Def Ghi I Oz    "
+      m = TestModel.create :string_column => " aé áb c, 1 2 3 DEF GHI i oz "
+      m.string_column.should == " Aé Áb C, 1 2 3 Def Ghi I Oz "
     end
 
     it :upcase do
-      TestModel.normalize :string_field, :with => :upcase
+      TestModel.normalize :string_column, :with => :upcase
 
-      m = TestModel.create :string_field => "   a   b c, 1 2 3 DEF GHI i oz    "
-      m.string_field.should == "   A   B C, 1 2 3 DEF GHI I OZ    "
+      m = TestModel.create :string_column => " a b c, 1 2 3 DEF GHI i oz "
+      m.string_column.should == " A B C, 1 2 3 DEF GHI I OZ "
     end
 
     it :nillify do
-      TestModel.normalize :string_field, :with => :nillify
+      TestModel.normalize :string_column, :with => :nillify
 
-      m = TestModel.create :string_field => "       "
-      m.string_field.should == nil
+      m = TestModel.create :string_column => " "
+      m.string_column.should == nil
     end
 
     it :lstrip do
-      TestModel.normalize :string_field, :with => :lstrip
+      TestModel.normalize :string_column, :with => :lstrip
 
-      m = TestModel.create :string_field => "   a   b c, 1 2 3 DEF GHI i oz    "
-      m.string_field.should == "a   b c, 1 2 3 DEF GHI i oz    "
+      m = TestModel.create :string_column => " a b c, 1 2 3 DEF GHI i oz "
+      m.string_column.should == "a b c, 1 2 3 DEF GHI i oz "
     end
 
     it :rstrip do
-      TestModel.normalize :string_field, :with => :rstrip
+      TestModel.normalize :string_column, :with => :rstrip
 
-      m = TestModel.create :string_field => "   a   b c, 1 2 3 DEF GHI i oz    "
-      m.string_field.should == "   a   b c, 1 2 3 DEF GHI i oz"
+      m = TestModel.create :string_column => " a b c, 1 2 3 DEF GHI i oz "
+      m.string_column.should == " a b c, 1 2 3 DEF GHI i oz"
     end
   end
 end

data/spec/schema.rb

@@ -1,6 +1,6 @@
 ActiveRecord::Schema.define(:version => 0) do
   create_table :test_models do |t|
-    t.string :string_field
-    t.integer :integer_field
+    t.string :string_column
+    t.integer :integer_column
   end
 end

data/spec/support/test_model.rb

@@ -1,3 +1,3 @@
 class TestModel < ActiveRecord::Base
-  attr_accessible :string_field, :integer_field
+  attr_accessible :string_column, :integer_column
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: normatron
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-22 00:00:00.000000000 Z
+date: 2012-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -71,7 +71,6 @@ files:
 - lib/normatron/active_record.rb
 - lib/normatron/conversors.rb
 - lib/normatron/version.rb
-- lib/tasks/normatron_tasks.rake
 - lib/normatron.rb
 - MIT-LICENSE
 - Rakefile

data/lib/tasks/normatron_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :normatron do
-#   # Task goes here
-# end