normatron 0.1.1 → 0.2.0

data/lib/normatron/filters.rb

@@ -1,12 +1,260 @@
-require "normatron/filters/conversions"
-require "normatron/filters/string_inflections"
+# encoding: UTF-8
+
+require 'active_support/multibyte/chars'
+require 'active_support/core_ext/string'
 
 module Normatron
   module Filters
-    class << self
-      def is_a_string?(value)
-        value.is_a?(ActiveSupport::Multibyte::Chars) || value.is_a?(String)
-      end
+    ##
+    # Converts a blank string on a nil object.
+    # 
+    # @example
+    #   blank("")            #=> nil
+    #   blank("     ")       #=> nil
+    #   blank("   \n   ")    #=> nil
+    #   blank("1")           #=> "1"
+    #   blank("It's blank?") #=> "It's blank?"
+    #   blank(123)           #=> 123
+    #
+    #   # For normalizations
+    #   normalize :attribute, :with => [:custom_filter, :blank]
+    # @param [String] value A character sequence
+    # @return [String, Nil] The object itself or nil
+    # @see http://api.rubyonrails.org/classes/String.html#method-i-blank-3F String#blank?
+    def self.blank(value)
+      return value unless string?(value) && value.to_s.blank?
+      nil
+    end
+
+    ##
+    # Converts the first character to uppercase and others to lowercase.
+    # 
+    # @example
+    #   capitalize("walter white") #=> "Walter white"
+    #   capitalize("wALTER WHITE") #=> "Walter white"
+    #   capitalize(123)            #=> 123
+    #
+    #   # For normalizations
+    #   normalize :attribute, :with => [:custom_filter, :capitalize]
+    # @param [String] value A character sequence
+    # @return [String, Object] The capitalized String or the object itself
+    # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-capitalize String#capitalize
+    # @see http://api.rubyonrails.org/classes/ActiveSupport/Multibyte/Chars.html#method-i-capitalize ActiveSupport::Multibyte::Chars#capitalize
+    def self.capitalize(value)
+      (string?(value) && eval_send(:capitalize, value)) || value
+    end
+
+    ##
+    # Replaces all underscores with dashes.
+    # 
+    # @example
+    #   dasherize("monty_python") #=> "monty-python"
+    #   dasherize("_.·-'*'-·._")  #=> "-.·-'*'-·.-"
+    #   dasherize(123)            #=> 123
+    #
+    #   # For normalizations
+    #   normalize :attribute, :with => [:custom_filter, :dasherize]
+    # @param [String] value A character sequence
+    # @return [String, Object] The dasherized String or the object itself
+    # @see http://api.rubyonrails.org/classes/String.html#method-i-dasherize String#dasherize
+    def self.dasherize(value)
+      (string?(value) && eval_send(:dasherize, value)) || value
+    end
+
+    ##
+    # Converts all characters to lowercase.
+    # 
+    # @example
+    #   downcase("VEGETA!!!") #=> "vegeta!!!"
+    #   downcase(123)         #=> 123
+    #
+    #   # For normalizations
+    #   normalize :attribute, :with => [:custom_filter, :downcase]
+    # @param [String] value A character sequence
+    # @return [String, Object] The lowercased String or the object itself
+    # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-downcase String#downcase
+    # @see http://api.rubyonrails.org/classes/ActiveSupport/Multibyte/Chars.html#method-i-downcase ActiveSupport::Multibyte::Chars#downcase
+    def self.downcase(value)
+      (string?(value) && eval_send(:downcase, value)) || value
+    end
+
+    ##
+    # Keep only the specified characters.
+    # Details about the options can be found in the Regexp class documentation.
+    # 
+    # @example
+    #   keep("Doom 3", :L)      #=> "Doom"    equivalent to /\p{L}/u
+    #   keep("Doom 3", :N)      #=> "3"       equivalent to /\p{N}/u
+    #   keep("Doom 3", :L, :N)  #=> "Doom3"   equivalent to /\p{L}\p{N}/u
+    #   keep("Doom 3", :Lu, :N) #=> "D3"      equivalent to /\p{Lu}\p{N}/u
+    #   keep("Doom ˩", :Latin)  #=> "Doom"    equivalent to /\p{Latin}/u
+    #
+    #   # For normalizations
+    #   normalize :attribute_a, :with => [[:keep, :Lu, :N]]
+    #   normalize :attribute_b, :with => [:custom_filter, [:keep, :L, :Nd]]
+    #   normalize :attribute_c, :with => [:custom_filter, {:keep => [:Latin, :Z]}]
+    # @param [String] value A character sequence
+    # @param [[Symbol]*] args Array of Symbols equivalent to Regexp for \\p{} construct.
+    # @return [String, Object] The clean character sequence or the object itself
+    # @see http://www.ruby-doc.org/core-1.9.3/Regexp.html Regexp
+    def self.keep(value, *args)
+      eval_regexp(value, true, args)
+    end
+
+    ##
+    # Remove trailing spaces.
+    # 
+    # @example
+    #   lstrip("   copyleft   ") #=> "copyleft   "
+    #
+    #   # For normalizations
+    #   normalize :attribute, :with => [:custom_filter, :lstrip]
+    # @param [String] value A character sequence
+    # @return [String, Object] The character sequence without trailing spaces or the object itself
+    # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-lstrip String#lstrip
+    def self.lstrip(value)
+      (string?(value) && eval_strip(value, true, false)) || value
+    end
+
+    ##
+    # Remove only the specified characters.
+    # Details about the options can be found in the Regexp class documentation.
+    # 
+    # @example
+    #   remove("Quake 3", :L)      #=> "3"            equivalent to /\p{L}/u
+    #   remove("Quake 3", :N)      #=> "Quake "       equivalent to /\p{N}/u
+    #   remove("Quake 3", :L, :N)  #=> " "            equivalent to /\p{L}\p{N}/u
+    #   remove("Quake 3", :Lu, :N) #=> "uake "        equivalent to /\p{Lu}\p{N}/u
+    #   remove("Quake ˩", :Latin)  #=> "Quake"        equivalent to /\p{Latin}/u
+    #
+    #   # For normalizations
+    #   normalize :attribute_a, :with => [[:remove, :Lu, :N]]
+    #   normalize :attribute_b, :with => [:custom_filter, [:remove, :L, :Nd]]
+    #   normalize :attribute_c, :with => [:custom_filter, {:remove => [:Latin, :Z]}]
+    # @param [String] value A character sequence
+    # @param [[Symbol]*] args Array of Symbols equivalent to Regexp for \\p{} construct.
+    # @return [String, Object] The clean character sequence or the object itself
+    # @see http://www.ruby-doc.org/core-1.9.3/Regexp.html Regexp
+    def self.remove(value, *args)
+      eval_regexp(value, false, args)
+    end
+
+    ##
+    # Remove leading spaces.
+    # 
+    # @example
+    #   rstrip("   copyright   ") #=> "   copyright"
+    #
+    #   # For normalizations
+    #   normalize :attribute, :with => [:custom_filter, :rstrip]
+    # @param [String] value A character sequence
+    # @return [String, Object] The character sequence without leading spaces or the object itself
+    # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-rstrip String#rstrip
+    def self.rstrip(value)
+      (string?(value) && eval_strip(value, false, true)) || value
+    end
+
+    ##
+    # Remove multiple occurences of the same character.
+    # If no option are given, all runs of identical characters are replaced by a single character.
+    # 
+    # @example
+    #   squeeze("yellow moon")                  #=> "yelow mon"
+    #   squeeze("  now   is  the", " ")         #=> " now is the"
+    #   squeeze("putters shoot balls", "m-z")   #=> "puters shot balls"
+    #
+    #   # For normalizations
+    #   normalize :attribute_a, :with => [:custom_filter, :squeeze]
+    #   normalize :attribute_b, :with => [:custom_filter, [:squeeze, "a-f"]]
+    #   normalize :attribute_c, :with => [:custom_filter, {:squeeze => ["a-f"]}]
+    # @param [String] value A character sequence
+    # @param [[String]*] args Chars to be affected
+    # @return [String, Object] The clean character sequence or the object itself
+    # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-squeeze String#squeeze
+    def self.squeeze(value, *args)
+      return value unless string?(value)
+      (args.any? && value.squeeze(args.first)) || value.squeeze
+    end
+
+    ##
+    # Strip and remove multiple spaces.
+    # 
+    # @example
+    #   squish("  the \n simpsons ") #=> "the simpsons"
+    #
+    #   # For normalizations
+    #   normalize :attribute, :with => [:custom_filter, :squish]
+    # @param [String] value A character sequence
+    # @return [String, Object] The clean character sequence or the object itself
+    #
+    # @see http://api.rubyonrails.org/classes/String.html#method-i-squish String#squish
+    def self.squish(value)
+      (string?(value) && value.squish) || value
+    end
+
+    ##
+    # Remove traling and leading spaces from the string.
+    # 
+    # @example
+    #   strip("   copy   ") #=> "copy"
+    #
+    #   # For normalizations
+    #   normalize :attribute, :with => [:custom_filter, :strip]
+    # @param [String] value A character sequence
+    # @return [String, Object] The stripped character sequence or the object itself
+    def self.strip(value)
+      (string?(value) && eval_strip(value, true, true)) || value
+    end
+
+    ##
+    # Converts all characters to uppercase.
+    # 
+    # @example
+    #   downcase("kakarotto!!!") #=> "KAKAROTTO!!!"
+    #   downcase(123)            #=> 123
+    #
+    #   # For normalizations
+    #   normalize :attribute, :with => [:custom_filter, :upcase]
+    # @param [String] value A character sequence
+    # @return [String, Object] The lowercased String or the object itself
+    # @see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-upcase String#upcase
+    # @see http://api.rubyonrails.org/classes/ActiveSupport/Multibyte/Chars.html#method-i-upcase ActiveSupport::Multibyte::Chars#upcase
+    def self.upcase(value)
+      (string?(value) && eval_send(:upcase, value)) || value
+    end
+
+    protected
+
+    def self.eval_regexp(value, keep, *args)
+      return value unless string?(value)
+      
+      options = args.flatten.compact.uniq
+
+      regex = options.map{|s| "\\p{#{s.to_s}}"} * ""
+      regex.prepend('^') if keep
+      regex = eval "/[#{regex}]/u"
+
+      value.gsub(regex, "")
+    end
+
+    def self.eval_send(method, value)
+      type = value.class
+      value = value.mb_chars if type == String
+      value = value.send(method)
+      (type == String && value.to_s) || value
+    end
+
+    def self.eval_strip(value, start, ending)
+      regex = []
+      regex << '\A\p{Zs}*' if start
+      regex << '\p{Zs}*\z' if ending
+      regex = eval "/#{regex * '|'}/u"
+
+      value.gsub(regex, '')
+    end
+
+    def self.string?(value)
+      value.is_a?(ActiveSupport::Multibyte::Chars) || value.is_a?(String)
     end
   end
 end

data/spec/configuration_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Normatron::Configuration do
+  before :each do
+    @instance = described_class.new
+  end
+
+  subject { @instance }
+
+  describe "#default_filters" do
+    it "should initializate" do
+      subject.default_filters.should == { squish: [], blank: [] }
+    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: [], blank: [], keep: [:L, :N], remove: [:S, :Z] }
+    end
+    it "should raise error for empty filters" do
+      lambda{ subject.default_filters = [] }.should raise_error
+    end
+  end
+
+  describe "::clean_filters" do
+    context "with wrong arguments" do
+      it { expect{ described_class.clean_filters(nil)     }.to raise_error }
+      it { expect{ described_class.clean_filters([])      }.to raise_error }
+      it { expect{ described_class.clean_filters(1)       }.to raise_error }
+      it { expect{ described_class.clean_filters([1])     }.to raise_error }
+      it { expect{ described_class.clean_filters([:a, 1]) }.to raise_error }
+      it { expect{ described_class.clean_filters([[1]])   }.to raise_error }
+    end
+
+    context "with single filter hash" do
+      it { described_class.clean_filters(:a         ).should == { a:[] } }
+      it { described_class.clean_filters([:a]       ).should == { a:[] } }
+      it { described_class.clean_filters([[:a]]     ).should == { a:[] } }
+      it { described_class.clean_filters([[:a, :b]] ).should == { a:[:b] } }
+      it { described_class.clean_filters([a: [:b]]  ).should == { a:[:b] } }
+    end
+
+    context "with double filters hash" do
+      it { described_class.clean_filters([:a, :b]           ).should == { a:[], b:[] } }
+      it { described_class.clean_filters([:a, b:[:c, :d]]   ).should == { a:[], b:[:c, :d] } }
+      it { described_class.clean_filters([:a, [:b, :c, :d]] ).should == { a:[], b:[:c, :d] } }
+    end
+
+    context "with trible filters hash" do
+      it { described_class.clean_filters([:a, [:b, :c, :d], { e: [:f, :g] }]    ).should == { a:[], b:[:c, :d], e: [:f, :g] } }
+      it { described_class.clean_filters([:a, { b: [:c, :d] }, { e: [:f, :g] }] ).should == { a:[], b:[:c, :d], e: [:f, :g] } }
+      it { described_class.clean_filters([:a, { b: [:c, :d], e: [:f, :g] }]     ).should == { a:[], b:[:c, :d], e: [:f, :g] } }
+    end
+  end
+end

data/spec/extensions/active_record_spec.rb

@@ -0,0 +1,114 @@
+require "spec_helper"
+
+describe Normatron::Extensions::ActiveRecord do
+  let(:model) { Model }
+  before(:each) { model.normalize_options = nil }
+
+  describe "::normalize" do
+    subject { model.normalize_options }
+    
+    specify("unknown attribute") { expect { model.normalize :abcdef }.to raise_error }
+    specify("nil attribute") { expect { model.normalize nil }.to raise_error }
+
+    context "with no filters" do
+      it "should use default filters" do
+        model.normalize :field_a
+        should == { field_a: { squish: [], blank: [] } }
+      end
+
+      it "should assoc to multiple attributes" do
+        model.normalize :field_a, :field_b, :field_c
+        should == { field_a: { squish: [], blank: [] },
+                    field_b: { squish: [], blank: [] },
+                    field_c: { squish: [], blank: [] } }
+      end
+
+      it "should stack attributes for multiple calls" do
+        model.normalize :field_a, :field_b
+        model.normalize :field_c
+        should == { field_a: { squish: [], blank: [] },
+                    field_b: { squish: [], blank: [] },
+                    field_c: { squish: [], blank: [] } }
+      end
+    end
+
+    context "with single filter" do
+      it "should set it" do
+        model.normalize :field_a, with: :upcase
+        should == { field_a: { upcase: [] } }
+      end
+
+      it "should set it as an array" do
+        model.normalize :field_a, with: [:upcase]
+        should == { field_a: { upcase: [] } }
+      end
+
+      it "should set it as an array" do
+        model.normalize :field_a, with: [[:keep, :L, :Z, :N]]
+        should == { field_a: { keep: [:L, :Z, :N] } }
+      end
+    end
+
+    context "with multiple filters" do
+      it "should set it" do
+        model.normalize :field_a, with: [:upcase, :dasherize]
+        should == { field_a: { upcase: [], dasherize: [] } }
+      end
+
+      it "should stack filters for multiple calls" do
+        model.normalize :field_a, with: :upcase
+        model.normalize :field_a, :field_b, with: [:blank, :squish]
+        should == { field_a: { upcase: [], blank: [], squish: [] },
+                    field_b: { blank: [], squish: []} }
+      end
+
+      it "should use filters with arguments passed as an array" do
+        model.normalize :field_a, with: [:upcase, [:keep, :L, :N], :blank]
+        should == { field_a: { upcase: [], keep: [:L, :N], blank: [] } }
+      end
+
+      it "should use filters with arguments passed as a hash" do
+        model.normalize :field_a, with: [:upcase, { keep: [:L, :N] }, :blank]
+        should == { field_a: { upcase: [], keep: [:L, :N], blank: [] } }
+      end
+    end
+  end
+
+  describe "#normalize_attributes" do
+    before(:each) { @instance = model.new }
+    let(:instance) { @instance }
+
+    it "should run instance method filter" do
+      model.class_eval do
+        define_method :test_filter do |value, glue, size|
+          v = value.gsub(/\p{Z}/u, '').split(//) * glue
+          v[0..size-1]
+        end
+      end
+
+      model.normalize :field_a, with: [[:test_filter, ".", 5]]
+      instance.field_a = " bla bla bla"
+      instance.normalize_attributes
+      instance.field_a.should == "b.l.a"
+    end
+
+    it "should run native filter" do
+      model.normalize :field_a, with: [keep: [:N]]
+      instance.field_a = "abc123"
+      instance.normalize_attributes
+      instance.field_a.should == "123"
+    end
+
+    it "should be called before validation" do
+      model.normalize :field_a, with: :downcase
+      instance.field_a = "XXXXXX"
+      instance.valid?
+      instance.field_a.should == "xxxxxx"
+    end
+
+    it "should raise error for wrong filters" do
+      model.normalize :field_a, with: :down
+      expect { instance.normalize_attributes }.to raise_error "Filter 'down' wasn't found."
+    end
+  end
+end

data/spec/filters_spec.rb

@@ -0,0 +1,199 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe Normatron::Filters do
+  
+  subject { described_class }
+  let(:mb_chars) { ActiveSupport::Multibyte::Chars }
+
+  describe "::blank" do
+    it { subject.blank("    .      "         ).should eq "    .      " }
+    it { subject.blank("           "         ).should be_nil }
+    it { subject.blank("\n \t \r \f"         ).should be_nil }
+    it { subject.blank("    .      "         ).should be_a String }
+    it { subject.blank("    .      ".mb_chars).should be_a mb_chars }
+    it { subject.blank(100                   ).should eq 100 }
+    it { subject.blank(nil                   ).should be_nil }
+  end
+
+  describe "::capitalize" do
+    it { subject.capitalize("abcDEF GhI"         ).should eq "Abcdef ghi" }
+    it { subject.capitalize("ébcDEF GhI"         ).should eq "Ébcdef ghi" }
+    it { subject.capitalize(" bcDEF GhI"         ).should eq " bcdef ghi" }
+    it { subject.capitalize("abcDEF GhI"         ).should be_a String }
+    it { subject.capitalize("abcDEF GhI".mb_chars).should be_a mb_chars }
+    it { subject.capitalize(100                  ).should eq 100 }
+    it { subject.capitalize(nil                  ).should be_nil }
+  end
+
+  describe "::dasherize" do
+    it { subject.dasherize("string_inflections"         ).should eq "string-inflections" }
+    it { subject.dasherize("string_inflections"         ).should be_a String }
+    it { subject.dasherize("string_inflections".mb_chars).should be_a mb_chars }
+    it { subject.dasherize(100                          ).should eq 100 }
+    it { subject.dasherize(nil                          ).should be_nil }
+  end
+
+  describe "::downcase" do
+    it { subject.downcase("ÇSDF !@# JHAS"         ).should eq "çsdf !@# jhas" }
+    it { subject.downcase("ÇSDF !@# JHAS"         ).should be_a String }
+    it { subject.downcase("ÇSDF !@# JHAS".mb_chars).should be_a mb_chars }
+    it { subject.downcase(100                     ).should eq 100 }
+    it { subject.downcase(nil                     ).should be_nil }
+  end
+
+  describe "::keep" do
+    it { subject.keep("1111aaaa", :L         ).should eq "aaaa" }
+    it { subject.keep("1111ܑܑܑܑ", :M          ).should eq "ܑܑܑܑ" }
+    it { subject.keep("1111!!!!", :P         ).should eq "!!!!" }
+    it { subject.keep("1111££££", :S         ).should eq "££££" }
+    it { subject.keep("11    ££", :Z         ).should eq "    " }
+    it { subject.keep("11\n\n££", :C         ).should eq "\n\n" }
+    it { subject.keep("1111aaaa", :L         ).should be_a String }
+    it { subject.keep("1111aaaa".mb_chars, :L).should be_a mb_chars }
+    it { subject.keep(1, :L                  ).should eq 1 }
+    it { subject.keep(1, :M                  ).should eq 1 }
+    it { subject.keep(1, :P                  ).should eq 1 }
+    it { subject.keep(1, :S                  ).should eq 1 }
+    it { subject.keep(1, :Z                  ).should eq 1 }
+    it { subject.keep(1, :C                  ).should eq 1 }
+    it { subject.keep(nil, :L                ).should be_nil }
+    it { subject.keep(nil, :M                ).should be_nil }
+    it { subject.keep(nil, :P                ).should be_nil }
+    it { subject.keep(nil, :S                ).should be_nil }
+    it { subject.keep(nil, :Z                ).should be_nil }
+    it { subject.keep(nil, :C                ).should be_nil }
+
+    context "with multiple options" do
+      it { subject.keep("1111aaaa!!!!", [:L, :N]).should eq "1111aaaa" }
+      it { subject.keep("1111ܑܑܑܑ!!!!", [:M, :N]).should eq "1111ܑܑܑܑ" }
+      it { subject.keep("1111!!!!aaaa", [:P, :L]).should eq "!!!!aaaa" }
+      it { subject.keep("1111££££aaaa", [:S, :N]).should eq "1111££££" }
+      it { subject.keep("11    ££aaaa", [:Z, :S]).should eq "    ££" }
+      it { subject.keep("11\n\n££aaaa", [:C, :N]).should eq "11\n\n" }
+    end
+
+    context "with wrong option" do
+      it { lambda { subject.keep("1111aaaa", :J) }.should raise_error }
+      it { lambda { subject.keep("1111ܑܑܑܑ", :J) }.should raise_error }
+      it { lambda { subject.keep("1111!!!!", :J) }.should raise_error }
+      it { lambda { subject.keep("1111££££", :J) }.should raise_error }
+      it { lambda { subject.keep("11    ££", :J) }.should raise_error }
+      it { lambda { subject.keep("11\n\n££", :J) }.should raise_error }
+    end
+
+    context "with wrong option inside multiple options array" do
+      it { lambda { subject.keep("1111aaaa", [:J, :N]) }.should raise_error }
+      it { lambda { subject.keep("1111ܑܑܑܑ", [:J, :N]) }.should raise_error }
+      it { lambda { subject.keep("1111!!!!", [:J, :N]) }.should raise_error }
+      it { lambda { subject.keep("1111££££", [:J, :N]) }.should raise_error }
+      it { lambda { subject.keep("11    ££", [:J, :N]) }.should raise_error }
+      it { lambda { subject.keep("11\n\n££", [:J, :N]) }.should raise_error }
+    end
+  end
+
+  describe "::lstrip" do
+    it { subject.lstrip("    1111    "         ).should eq "1111    " }
+    it { subject.lstrip("    1111    "         ).should be_a String }
+    it { subject.lstrip("    1111    ".mb_chars).should be_a mb_chars }
+    it { subject.lstrip(1).should eq 1 }
+    it { subject.lstrip(nil).should be_nil }
+  end
+
+  describe "::remove" do
+    it { subject.remove("1111aaaa", :L         ).should eq "1111" }
+    it { subject.remove("1111ܑܑܑܑ", :M          ).should eq "1111" }
+    it { subject.remove("1111!!!!", :P         ).should eq "1111" }
+    it { subject.remove("1111££££", :S         ).should eq "1111" }
+    it { subject.remove("11    ££", :Z         ).should eq "11££" }
+    it { subject.remove("11\n\n££", :C         ).should eq "11££" }
+    it { subject.remove("1111aaaa", :L         ).should be_a String }
+    it { subject.remove("1111aaaa".mb_chars, :L).should be_a mb_chars }
+    it { subject.remove(1, :L                  ).should eq 1 }
+    it { subject.remove(1, :M                  ).should eq 1 }
+    it { subject.remove(1, :P                  ).should eq 1 }
+    it { subject.remove(1, :S                  ).should eq 1 }
+    it { subject.remove(1, :Z                  ).should eq 1 }
+    it { subject.remove(1, :C                  ).should eq 1 }
+    it { subject.remove(nil, :L                ).should be_nil }
+    it { subject.remove(nil, :M                ).should be_nil }
+    it { subject.remove(nil, :P                ).should be_nil }
+    it { subject.remove(nil, :S                ).should be_nil }
+    it { subject.remove(nil, :Z                ).should be_nil }
+    it { subject.remove(nil, :C                ).should be_nil }
+
+    context "with multiple options" do
+      it { subject.remove("1111aaaa!!!!", [:L, :N]).should eq "!!!!" }
+      it { subject.remove("1111ܑܑܑܑ!!!!", [:M, :N]).should eq "!!!!" }
+      it { subject.remove("1111!!!!aaaa", [:P, :L]).should eq "1111" }
+      it { subject.remove("1111££££aaaa", [:S, :N]).should eq "aaaa" }
+      it { subject.remove("11    ££aaaa", [:Z, :S]).should eq "11aaaa" }
+      it { subject.remove("11\n\n££aaaa", [:C, :N]).should eq "££aaaa" }
+    end
+
+    context "with wrong option" do
+      it { lambda { subject.remove("1111aaaa", :J) }.should raise_error }
+      it { lambda { subject.remove("1111ܑܑܑܑ", :J) }.should raise_error }
+      it { lambda { subject.remove("1111!!!!", :J) }.should raise_error }
+      it { lambda { subject.remove("1111££££", :J) }.should raise_error }
+      it { lambda { subject.remove("11    ££", :J) }.should raise_error }
+      it { lambda { subject.remove("11\n\n££", :J) }.should raise_error }
+    end
+
+    context "with wrong option inside multiple options array" do
+      it { lambda { subject.remove("1111aaaa", [:J, :N]) }.should raise_error }
+      it { lambda { subject.remove("1111ܑܑܑܑ", [:J, :N]) }.should raise_error }
+      it { lambda { subject.remove("1111!!!!", [:J, :N]) }.should raise_error }
+      it { lambda { subject.remove("1111££££", [:J, :N]) }.should raise_error }
+      it { lambda { subject.remove("11    ££", [:J, :N]) }.should raise_error }
+      it { lambda { subject.remove("11\n\n££", [:J, :N]) }.should raise_error }
+    end
+  end
+
+  describe "::rstrip" do
+    it { subject.rstrip("    1111    "         ).should eq "    1111" }
+    it { subject.rstrip("    1111    "         ).should be_a String }
+    it { subject.rstrip("    1111    ".mb_chars).should be_a mb_chars }
+    it { subject.rstrip(1                      ).should eq 1 }
+    it { subject.rstrip(nil                    ).should be_nil }
+  end
+
+  describe "::squeeze" do
+    it { subject.squeeze(" 1  22   333   4444    "         ).should eq " 1 2 3 4 " }
+    it { subject.squeeze(" 1  22   333   4444    "         ).should be_a String }
+    it { subject.squeeze(" 1  22   333   4444    ".mb_chars).should be_a mb_chars }
+    it { subject.squeeze(1                                 ).should eq 1 }
+    it { subject.squeeze(nil                               ).should be_nil }
+
+    context "with options" do
+      it { subject.squeeze("aaabbbcccdddeeefff", "b-d"         ).should eq "aaabcdeeefff" }
+      it { subject.squeeze("aaabbbcccdddeeefff".mb_chars, "b-d").should eq "aaabcdeeefff".mb_chars }
+    end
+  end
+
+  describe "::squish" do
+    it { subject.squish("    11    11    "         ).should eq "11 11" }
+    it { subject.squish("    11\n\n11    "         ).should eq "11 11" }
+    it { subject.squish("    11    11    "         ).should be_a String }
+    it { subject.squish("    11    11    ".mb_chars).should be_a mb_chars }
+    it { subject.squish(1                          ).should eq 1 }
+    it { subject.squish(nil                        ).should be_nil }
+  end
+
+  describe "::strip" do
+    it { subject.strip("    1111    "         ).should eq "1111" }
+    it { subject.strip("    1111    "         ).should be_a String }
+    it { subject.strip("    1111    ".mb_chars).should be_a mb_chars }
+    it { subject.strip(1                      ).should eq 1 }
+    it { subject.strip(nil                    ).should be_nil }
+  end
+
+  describe "::upcase" do
+    it { subject.upcase("Çsdf !@# éhas"         ).should eq "ÇSDF !@# ÉHAS" }
+    it { subject.upcase("Çsdf !@# éhas"         ).should be_a String }
+    it { subject.upcase("Çsdf !@# éhas".mb_chars).should be_a mb_chars }
+    it { subject.upcase(100                     ).should eq 100 }
+    it { subject.upcase(nil                     ).should be_nil }
+  end
+end