normatron 0.2.1 → 0.3.0

data/lib/normatron/filters/squish_filter.rb

@@ -0,0 +1,28 @@
+require 'normatron/filters/helpers'
+
+module Normatron
+  module Filters
+    module SquishFilter
+
+      ##
+      # Strip input, remove line-breaks and multiple spaces.
+      # 
+      # @example
+      #   SquishFilter.evaluate("   the simpsons   ") #=> "the simpsons"
+      #   SquishFilter.evaluate("family      guy")    #=> "family guy"
+      #   SquishFilter.evaluate("the \n simpsons")    #=> "the simpsons"
+      #   SquishFilter.evaluate("the\nsimpsons")      #=> "the simpsons"
+      #
+      # @example Using as ActiveRecord::Base normalizer
+      #   normalize :attribute, :with => [:custom_filter, :squish]
+      #
+      # @param [String] input A character sequence
+      # @return [String] The clean character sequence or the object itself
+      # @see http://api.rubyonrails.org/classes/String.html#method-i-squish String#squish
+      # @see SqueezeFilter Normatron::Filters::SqueezeFilter
+      def self.evaluate(input)
+        input.kind_of?(String) ? input.squish : input
+      end
+    end
+  end
+end

data/lib/normatron/filters/strip_filter.rb

@@ -0,0 +1,33 @@
+require 'normatron/filters/helpers'
+
+module Normatron
+  module Filters
+    module StripFilter
+      extend Helpers
+
+      ##
+      # Remove traling and/or leading spaces from the string.
+      # 
+      # @example
+      #   StripFilter.evaluate("   copy   ")      #=> "copy"
+      #   StripFilter.evaluate("   copy   ", :L)  #=> "copy   "
+      #   StripFilter.evaluate("   copy   ", :R)  #=> "   copy"
+      #   StripFilter.evaluate("   copy   ", :LR) #=> "copy"
+      #
+      # @example Using as ActiveRecord::Base normalizer
+      #   normalize :attribute_a, :with => :strip
+      #   normalize :attribute_b, :with => { :strip => :L }
+      #   normalize :attribute_c, :with => [:custom_filter, :strip]
+      #   normalize :attribute_d, :with => [:custom_filter, [:strip, :L]]
+      #   normalize :attribute_e, :with => [:custom_filter, {:strip => :R}]
+      #
+      # @param [String] input A character sequence
+      # @param [Symbol] option :L to strip trailing spaces, :R for leading spaces and :LR for both
+      # @return [String] The character sequence without trailing and leading spaces or the object itself
+      # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-strip String#strip
+      def self.evaluate(input, option=:LR)
+        input.kind_of?(String) ? evaluate_strip(input, option) : input
+      end
+    end
+  end
+end

data/lib/normatron/filters/swapcase_filter.rb

@@ -0,0 +1,30 @@
+require 'normatron/filters/helpers'
+
+module Normatron
+  module Filters
+    module SwapcaseFilter
+      extend Helpers
+
+      ##
+      # Replaces uppercased characters by lowercased and vice versa.
+      # 
+      # @example
+      #   SwapcaseFilter.evaluate("As you Wish!") #=> "aS YOU wISH!"
+      #
+      # @example Using as ActiveRecord::Base normalizer
+      #   normalize :attribute_a, :with => :swapcase
+      #   normalize :attribute_b, :with => [:custom_filter, :swapcase]
+      #
+      # @param [String] input A character sequence
+      # @return [String] The swapped case character sequence or the object itself
+      # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-swapcase String#swapcase
+      # @see DownFilter Normatron::Filters::DownFilter
+      # @see TitleizeFilter Normatron::Filters::TitleizeFilter
+      # @see UpcaseFilter Normatron::Filters::UpcaseFilter
+      def self.evaluate(input)
+        return input unless input.kind_of?(String)
+        input.gsub(/([\p{Ll}])|(\p{Lu})|([^\p{Ll}\p{Lu}])/u) { $3 || ($2 ? mb_send(:downcase, $2) : mb_send(:upcase, $1)) }
+      end
+    end
+  end
+end

data/lib/normatron/filters/titleize_filter.rb

@@ -0,0 +1,29 @@
+require 'normatron/filters/helpers'
+
+module Normatron
+  module Filters
+    module TitleizeFilter
+      extend Helpers
+
+      ##
+      # Capitalizes the first character of each word.
+      # 
+      # @example
+      #   TitleizeFilter.evaluate("at your will!") #=> "At Your Will!"
+      #
+      # @example Using as ActiveRecord::Base normalizer
+      #   normalize :attribute_a, :with => :titleize
+      #   normalize :attribute_b, :with => [:custom_filter, :titleize]
+      #
+      # @param [String] input A character sequence
+      # @return [String] The titleized character sequence or the object itself
+      # @see http://api.rubyonrails.org/classes/ActiveSupport/Multibyte/Chars.html#method-i-titleize ActiveSupport::Multibyte::Chars#titleize
+      # @see DownFilter Normatron::Filters::DownFilter
+      # @see SwapcaseFilter Normatron::Filters::SwapcaseFilter
+      # @see UpcaseFilter Normatron::Filters::UpcaseFilter
+      def self.evaluate(input)
+        input.kind_of?(String) ? mb_send(:titleize, input) : input
+      end
+    end
+  end
+end

data/lib/normatron/filters/underscore_filter.rb

@@ -0,0 +1,45 @@
+require 'normatron/filters/helpers'
+
+module Normatron
+  module Filters
+    module UnderscoreFilter
+      extend Helpers
+
+      ##
+      # Makes an underscored, lowercase form from the expression in the string.
+      #
+      # Changes ‘::’ to ‘/’ to convert namespaces to paths.
+      #
+      # As a rule of thumb you can think of underscore as the inverse of camelize, though there are cases where that does not hold:
+      #   "SSLError".underscore.camelize # => "SslError"
+      # 
+      # @example
+      #   UnderscoreFilter.evaluate("ActiveRecord::Errors") #=> "active_record/errors"
+      #
+      # @example Using as ActiveRecord::Base normalizer
+      #   normalize :attribute_a, :with => :underscore
+      #   normalize :attribute_b, :with => [:custom_filter, :underscore]
+      #   normalize :attribute_c, :with => [[:underscore, :lower]]
+      #   normalize :attribute_d, :with => [{:underscore => :lower}]
+      #   normalize :attribute_e, :with => [:custom_filter, [:underscore, :lower]]
+      #   normalize :attribute_f, :with => [:custom_filter, {:underscore => :lower}]
+      #
+      # @param [String] input A character sequence
+      # @return [String] The underscored character sequence or the object itself
+      # @see http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-underscore ActiveSupport::Inflector#underscore
+      # @see CamelizeFilter Normatron::Filters::CamelizeFilter
+      # @todo Performance tests
+      # @todo Exception class
+      def self.evaluate(input)
+        return input unless input.kind_of?(String)
+
+        input.gsub!(/::/, '/')
+        input.gsub!(/(?:([\p{Ll}\p{Lu}\d])|^)(#{acronym_regex})(?=\b|[^\p{Ll}])/u) { "#{$1}#{$1 && '_'}#{mb_send(:downcase, $2)}" }
+        input.gsub!(/([\p{Lu}\d]+)([\p{Lu}][\p{Ll}])/u,'\1_\2')
+        input.gsub!(/([\p{Ll}\d])([\p{Lu}])/u,'\1_\2')
+        input.tr!("-", "_")
+        mb_send(:downcase, input)
+      end
+    end
+  end
+end

data/lib/normatron/filters/upcase_filter.rb

@@ -0,0 +1,29 @@
+require 'normatron/filters/helpers'
+
+module Normatron
+  module Filters
+    module UpcaseFilter
+      extend Helpers
+
+      ##
+      # Uppercase all characters.
+      # 
+      # @example
+      #   upcase("borderlands") #=> "BORDERLANDS"
+      #
+      # @example Using as ActiveRecord::Base normalizer
+      #   normalize :attribute_a, :with => :upcase
+      #   normalize :attribute_b, :with => [:custom_filter, :upcase]
+      #
+      # @return [String, Chars] The uppercased character sequence 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
+      # @see DownFilter Normatron::Filters::DownFilter
+      # @see TitleizeFilter Normatron::Filters::TitleizeFilter
+      # @see SwapcaseFilter Normatron::Filters::SwapcaseFilter
+      def self.evaluate(input)
+        input.kind_of?(String) ? mb_send(:upcase, input) : input
+      end
+    end
+  end
+end

data/lib/normatron/version.rb

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

data/spec/normatron/configuration_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'normatron/configuration'
+
+describe Normatron::Configuration do
+
+  before :each do
+    @instance = described_class.new
+  end
+
+  subject { @instance }
+
+  describe :default_filters do
+    it "should be initialized" do
+      subject.default_filters.should == { blank: nil, squish: nil }
+    end
+
+    it "should parse and set filters properly" do
+      subject.default_filters = :upcase, :blank, { keep: [:L, :N] }, [:remove, :S, :Z]
+      subject.default_filters.should == { upcase: nil, blank: nil, keep: [:L, :N], remove: [:S, :Z] }
+    end
+  end
+
+  describe :filters do
+    it "should be initialized" do
+      subject.filters[:blank]     .should eq Normatron::Filters::BlankFilter
+      subject.filters[:camelize]  .should eq Normatron::Filters::CamelizeFilter
+      subject.filters[:capitalize].should eq Normatron::Filters::CapitalizeFilter
+      subject.filters[:chomp]     .should eq Normatron::Filters::ChompFilter
+      subject.filters[:dasherize] .should eq Normatron::Filters::DasherizeFilter
+      subject.filters[:downcase]  .should eq Normatron::Filters::DowncaseFilter
+      subject.filters[:dump]      .should eq Normatron::Filters::DumpFilter
+      subject.filters[:keep]      .should eq Normatron::Filters::KeepFilter
+      subject.filters[:remove]    .should eq Normatron::Filters::RemoveFilter
+      subject.filters[:squeeze]   .should eq Normatron::Filters::SqueezeFilter
+      subject.filters[:squish]    .should eq Normatron::Filters::SquishFilter
+      subject.filters[:strip]     .should eq Normatron::Filters::StripFilter
+      subject.filters[:swapcase]  .should eq Normatron::Filters::SwapcaseFilter
+      subject.filters[:titleize]  .should eq Normatron::Filters::TitleizeFilter
+      subject.filters[:underscore].should eq Normatron::Filters::UnderscoreFilter
+      subject.filters[:upcase]    .should eq Normatron::Filters::UpcaseFilter
+    end
+
+    it "should allow add new filters" do
+      subject.filters[:smile] = MyFilters::SmileFilter
+      subject.filters[:smile].should eq MyFilters::SmileFilter
+    end
+
+    it "should allow remove filters" do
+      lambda { subject.filters.delete(subject.filters.keys.first) }.should_not raise_error
+    end
+  end
+
+  describe :add_orm do
+    it "should include ActiveRecord extension" do
+      ActiveRecord::Base.include?(Normatron::Extensions::ActiveRecord).should be_false
+      subject.add_orm Normatron::Extensions::ActiveRecord
+      ActiveRecord::Base.include?(Normatron::Extensions::ActiveRecord).should be_true
+    end
+  end
+end

data/spec/normatron/extensions/active_record_spec.rb

@@ -0,0 +1,96 @@
+require 'normatron'
+require 'spec_helper'
+
+describe Normatron::Extensions::ActiveRecord do
+  
+  it { subject.constants.should include(:ORM_CLASS) }
+
+  let(:ext) { Normatron::Extensions }
+  let(:configuration) { Normatron.configuration }
+  let(:model) { User }
+
+  before(:all) { ActiveRecord::Base.send(:include, Normatron::Extensions::ActiveRecord) }
+  before(:each) { model.normalize_filters = nil }
+  after(:all) do
+    ActiveRecord.send(:remove_const, :Base)
+    load 'active_record/base.rb'
+  end
+
+
+  describe :normalize do
+    subject { model }
+
+    it "should raise UnknownAttributeError" do
+      lambda { subject.normalize :unknown         }.should raise_error(ext::UnknownAttributeError)
+      lambda { subject.normalize nil              }.should raise_error(ext::UnknownAttributeError)
+      lambda { subject.normalize :phone, :unknown }.should raise_error(ext::UnknownAttributeError)
+    end
+
+    it "should append default filters" do
+      subject.normalize :login, :email
+      subject.normalize_filters.should == { :login => configuration.default_filters,
+                                            :email => configuration.default_filters }
+    end
+
+    it "should stack filters for multiple calls" do
+      subject.normalize :login
+      subject.normalize :login, :with => :upcase
+      subject.normalize_filters.should == { :login => configuration.default_filters.merge({ :upcase => nil }) }
+    end
+
+    it "should append multiple attributes" do
+      subject.normalize :login, :email, :phone
+      subject.normalize_filters.should == { login: { squish: nil, blank: nil },
+                                            email: { squish: nil, blank: nil },
+                                            phone: { squish: nil, blank: nil } }
+    end
+
+    it "should allow multiple filters" do
+      subject.normalize :login, :with => [:upcase, :blank]
+      subject.normalize_filters.should == { login: { upcase: nil, blank: nil } }
+    end
+
+    it "should allow multiple filters" do
+      subject.normalize :login, :with => [[:keep, :L], { :remove => [:N] }]
+      subject.normalize_filters.should == { login: { keep: [:L], remove: [:N] } }
+    end
+  end
+
+  describe :apply_normalizations do
+    before(:each) { @instance = model.new }
+    subject { @instance }
+
+    it "should run instance method filter" do
+      model.class_eval do
+        define_method :sad_face do |value|
+          value + " =("
+        end
+      end
+
+      model.normalize :login, :with => :sad_face
+      subject.login = "..."
+      subject.apply_normalizations
+      subject.login.should eq "... =("
+    end
+
+    it "should run native filter" do
+      model.normalize :login, :with => :squish
+      subject.login = "  word  "
+      subject.apply_normalizations
+      subject.login.should eq "word"
+    end
+
+    it "should be called before validation" do
+      model.normalize :login, :with => :blank
+      subject.login = "    "
+      subject.valid?
+      subject.login.should == nil
+    end
+
+    it "should raise UnknownFilterError" do
+      model.normalize :login, :with => :unknown
+      subject.login = "    "
+      lambda { subject.apply_normalizations }.should raise_error(ext::UnknownFilterError)
+    end
+  end
+end

data/spec/normatron/filters/blank_filter_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'normatron/filters/blank_filter'
+
+describe Normatron::Filters::BlankFilter do
+  it_should_behave_like "string processor"
+  it_should_behave_like "evaluable filter", ["18pm"], "18pm"
+
+  describe :blank do
+    let(:word) { "phase" }
+    it { subject.send(:evaluate, "           ").should be_nil }
+    it { subject.send(:evaluate, "\n \t \r \f").should be_nil }
+    it { subject.send(:evaluate, "\n\t\r\f"   ).should be_nil }
+    it { subject.send(:evaluate, word         ).should equal word }
+  end
+end

data/spec/normatron/filters/camelize_filter_spec.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'normatron/filters/camelize_filter'
+
+describe Normatron::Filters::CamelizeFilter do
+  it_should_behave_like "string processor"
+  it_should_behave_like "evaluable filter", ["active_record/errors"                    ], "ActiveRecord::Errors"
+  it_should_behave_like "evaluable filter", ["active_record/errors", :upper            ], "ActiveRecord::Errors"
+  it_should_behave_like "evaluable filter", ["active_record/errors", :lower            ], "activeRecord::Errors"
+  it_should_behave_like "evaluable filter", ["dados_históricos/período/empresa"        ], "DadosHistóricos::Período::Empresa"
+  it_should_behave_like "evaluable filter", ["dados_históricos/período/empresa", :upper], "DadosHistóricos::Período::Empresa"
+  it_should_behave_like "evaluable filter", ["dados_históricos/período/empresa", :lower], "dadosHistóricos::Período::Empresa"
+  it_should_behave_like "evaluable filter", ["ímpar_par/norte_sul"                     ], "ÍmparPar::NorteSul"
+  it_should_behave_like "evaluable filter", ["ímpar_par/norte_sul", :upper             ], "ÍmparPar::NorteSul"
+  it_should_behave_like "evaluable filter", ["ímpar_par/norte_sul", :lower             ], "ímparPar::NorteSul"
+  
+  context "should affect acronyms" do
+    let(:inflections) { ActiveSupport::Inflector::Inflections.instance }
+
+    before(:all) do
+      inflections.acronym 'HTTP'
+      inflections.acronym 'SSL'
+      inflections.acronym 'Xml'
+      inflections.acronym 'docType'
+    end
+
+    after(:all) do
+      inflections.acronyms.delete("http")
+      inflections.acronyms.delete("ssl")
+      inflections.acronyms.delete("xml")
+      inflections.acronyms.delete("doctype")
+    end
+
+    it_should_behave_like "evaluable filter", ["http_address/ssl/xml_file/doctype"        ], "HTTPAddress::SSL::XmlFile::docType"
+    it_should_behave_like "evaluable filter", ["http_address/ssl/xml_file/doctype", :upper], "HTTPAddress::SSL::XmlFile::docType"
+    it_should_behave_like "evaluable filter", ["http_address/ssl/xml_file/doctype", :lower], "httpAddress::SSL::XmlFile::docType"
+    it_should_behave_like "evaluable filter", ["doctype_stop/run_ssl/xml/mix_http"        ], "docTypeStop::RunSSL::Xml::MixHTTP"
+    it_should_behave_like "evaluable filter", ["doctype_stop/run_ssl/xml/mix_http", :upper], "docTypeStop::RunSSL::Xml::MixHTTP"
+    it_should_behave_like "evaluable filter", ["doctype_stop/run_ssl/xml/mix_http", :lower], "doctypeStop::RunSSL::Xml::MixHTTP"
+  end
+end

data/spec/normatron/filters/capitalize_filter_spec.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'normatron/filters/capitalize_filter'
+
+describe Normatron::Filters::CapitalizeFilter do
+  it_should_behave_like "string processor"
+  it_should_behave_like "evaluable filter", ["i love winter" ], "I love winter"
+  it_should_behave_like "evaluable filter", ["I LOVE WINTER" ], "I love winter"
+  it_should_behave_like "evaluable filter", ["ó, vida cruel!"], "Ó, vida cruel!"
+  it_should_behave_like "evaluable filter", ["Ó, VIDA CRUEL!"], "Ó, vida cruel!"
+  it_should_behave_like "evaluable filter", ["1 minute"      ], "1 minute"
+  it_should_behave_like "evaluable filter", ["1 MINUTE"      ], "1 minute"
+end

data/spec/normatron/filters/chomp_filter_spec.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'normatron/filters/chomp_filter'
+
+describe Normatron::Filters::ChompFilter do
+  it_should_behave_like "string processor"
+  it_should_behave_like "evaluable filter", ["show me the money"                   ], "show me the money"
+  it_should_behave_like "evaluable filter", ["show me the money\n"                 ], "show me the money"
+  it_should_behave_like "evaluable filter", ["show me the money\r"                 ], "show me the money"
+  it_should_behave_like "evaluable filter", ["show me the money\r\n"               ], "show me the money"
+  it_should_behave_like "evaluable filter", ["show me the money\n\r"               ], "show me the money\n"
+  it_should_behave_like "evaluable filter", ["show me the money", " money"         ], "show me the"
+  it_should_behave_like "evaluable filter", ["show me the money", " money".mb_chars], "show me the"
+end