attribute-filters 1.4.0 → 2.0.0

data/lib/attribute-filters/common_filters/bare.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2012 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:LGPL-LICENSE GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# 
+# This file contains ActiveModel::AttributeFilters::Common::Bare module.
+
+# @abstract This namespace is shared with ActveModel.
+module ActiveModel
+  module AttributeFilters
+    # This module contains common, ready-to-use filtering methods.
+    module Common   
+
+      # This module contains bare attribute filters.
+      module Bare
+        extend CommonFilter
+
+        # This submodule contains class methods used to easily define filter.
+        module ClassMethods
+        end # module ClassMethods
+
+      end # module Bare
+
+      include Bare
+
+    end # module Common
+  end # module AttributeFilters
+end # module ActiveModel

data/lib/attribute-filters/common_filters/case.rb

@@ -16,6 +16,7 @@ module ActiveModel
       # This module contains attribute filters responsible for changing the case of letters.
       module Case
         extend CommonFilter
+
         # Downcases attributes.
         # 
         # The attrubutes to be downcased are taken from the attribute set
@@ -23,16 +24,17 @@ module ActiveModel
         # used with multibyte strings (containing diacritics).
         # 
         # @note If a value of currently processed attribute is an array
-        #  then any element of the array is changed.
+        #  then any element of the array is changed. The same with hash (its values are changed).
         # 
         # @return [void]
         def downcase_attributes
           filter_attrs_from_set(:should_be_downcased) do |atr|
-            AttributeFiltersHelpers.each_element(atr, String) do |v|
+            AFHelpers.each_element(atr, String) do |v|
               v.mb_chars.downcase.to_s
             end
           end
         end
+        filtering_method :downcase_attributes, :should_be_downcased
 
         # This submodule contains class methods used to easily define filter.
         module ClassMethods
@@ -40,7 +42,9 @@ module ActiveModel
           def downcase_attributes(*args)
             attributes_that(:should_be_downcased, args)
           end
-          alias_method :downcase_attribute, :downcase_attributes
+          alias_method :downcase_attribute,   :downcase_attributes
+          alias_method :downcases_attribute,  :downcase_attributes
+          alias_method :downcases_attributes, :downcase_attributes
         end # module ClassMethods
 
         # Upcases attributes.
@@ -50,16 +54,17 @@ module ActiveModel
         # used with multibyte strings (containing diacritics).
         # 
         # @note If a value of currently processed attribute is an array
-        #  then any element of the array is changed.
+        #  then any element of the array is changed. The same with hash (its values are changed).
         # 
         # @return [void]
         def upcase_attributes
           filter_attrs_from_set(:should_be_upcased) do |atr|
-            AttributeFiltersHelpers.each_element(atr, String) do |v|
+            AFHelpers.each_element(atr, String) do |v|
               v.mb_chars.upcase.to_s
             end
           end
         end
+        filtering_method :upcase_attributes, :should_be_upcased
 
         # This submodule contains class methods used to easily define filter.
         module ClassMethods
@@ -67,7 +72,9 @@ module ActiveModel
           def upcase_attributes(*args)
             attributes_that(:should_be_upcased, args)
           end
-          alias_method :upcase_attribute, :upcase_attributes
+          alias_method :upcase_attribute,   :upcase_attributes
+          alias_method :upcases_attribute,  :upcase_attributes
+          alias_method :upcases_attributes, :upcase_attributes
         end # module ClassMethods
 
         # Titleizes attributes.
@@ -77,16 +84,17 @@ module ActiveModel
         # used with multibyte strings (containing diacritics).
         # 
         # @note If a value of currently processed attribute is an array
-        #  then any element of the array is changed.
+        #  then any element of the array is changed. The same with hash (its values are changed).
         # 
         # @return [void]
         def titleize_attributes
           filter_attrs_from_set(:should_be_titleized) do |atr|
-            AttributeFiltersHelpers.each_element(atr, String) do |v|
+            AFHelpers.each_element(atr, String) do |v|
               v.mb_chars.titleize.to_s
             end
           end
         end
+        filtering_method :titleize_attributes, :should_be_titleized
 
         # This submodule contains class methods used to easily define filter.
         module ClassMethods
@@ -94,7 +102,9 @@ module ActiveModel
           def titleize_attributes(*args)
             attributes_that(:should_be_titleized, args)
           end
-          alias_method :titleize_attribute, :titleize_attributes
+          alias_method :titleize_attribute,   :titleize_attributes
+          alias_method :titleizes_attribute,  :titleize_attributes
+          alias_method :titleizes_attributes, :titleize_attributes
         end # module ClassMethods
 
         # Capitalizes attributes.
@@ -104,16 +114,17 @@ module ActiveModel
         # used with multibyte strings (containing diacritics).
         # 
         # @note If a value of currently processed attribute is an array
-        #  then any element of the array is changed.
+        #  then any element of the array is changed. The same with hash (its values are changed).
         # 
         # @return [void]
         def capitalize_attributes
           filter_attrs_from_set(:should_be_capitalized) do |atr|
-            AttributeFiltersHelpers.each_element(atr, String) do |v|
+            AFHelpers.each_element(atr, String) do |v|
               v.mb_chars.capitalize.to_s
             end
           end
         end
+        filtering_method :capitalize_attributes, :should_be_capitalized
 
         # Fully capitalizes attributes (capitalizes each word and squeezes spaces).
         # 
@@ -122,18 +133,18 @@ module ActiveModel
         # This method is safe to be used with multibyte strings (containing diacritics).
         # 
         # @note If a value of currently processed attribute is an array
-        #  then any element of the array is changed.
+        #  then any element of the array is changed. The same with hash (its values are changed).
         # 
         # @return [void]
-        def titleize_with_squeezed_spaces
-          s = attribute_set_simple(:should_be_fully_capitalized) + attribute_set_simple(:should_be_titleized)
-          filter_attrs_from_set(s) do |atr|
-            AttributeFiltersHelpers.each_element(atr, String) do |v|
+        def fully_capitalize_attributes
+          filter_attrs_from_set(:should_be_fully_capitalized) do |atr|
+            AFHelpers.each_element(atr, String) do |v|
               v.mb_chars.split(' ').map { |n| n.capitalize }.join(' ')
             end
           end          
         end
-        alias_method :fully_capitalize_attributes, :titleize_with_squeezed_spaces
+        filtering_method  :fully_capitalize_attributes, :should_be_fully_capitalized
+        alias_method      :titleize_with_squeezed_spaces, :fully_capitalize_attributes
 
         # This submodule contains class methods used to easily define filter.
         module ClassMethods
@@ -141,13 +152,17 @@ module ActiveModel
           def capitalize_attributes(*args)
             attributes_that(:should_be_capitalized, args)
           end
-          alias_method :capitalize_attribute, :capitalize_attributes
+          alias_method :capitalize_attribute,   :capitalize_attributes
+          alias_method :capitalizes_attribute,  :capitalize_attributes
+          alias_method :capitalizes_attributes, :capitalize_attributes
 
           # Registers attributes that should be fully capitalized.
           def fully_capitalize_attributes(*args)
             attributes_that(:should_be_fully_capitalized, args)
           end
-          alias_method :fully_capitalize_attribute, :fully_capitalize_attributes
+          alias_method :fully_capitalize_attribute,    :fully_capitalize_attributes
+          alias_method :fully_capitalizes_attribute,   :fully_capitalize_attributes
+          alias_method :fully_capitalizes_attributes,  :fully_capitalize_attributes
           alias_method :titleize_with_squeezed_spaces, :fully_capitalize_attributes
         end # module ClassMethods
       end # module Case

data/lib/attribute-filters/common_filters/convert.rb

@@ -0,0 +1,259 @@
+# encoding: utf-8
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2012 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:LGPL-LICENSE GNU Lesser General Public License} or {file:COPYING Ruby License}.
+# 
+# This file contains ActiveModel::AttributeFilters::Common::Convert module
+# containing ready-to-use filtering methods for performing the type conversion.
+
+# @abstract This namespace is shared with ActveModel.
+module ActiveModel
+  module AttributeFilters
+    # This module contains common, ready-to-use filtering methods.
+    module Common   
+
+      # This module contains attribute filters responsible for converting the attributes.
+      module Convert
+        extend CommonFilter
+
+        # Helper that is used by all converting filters.
+        def attributes_convert(set_name, default_key, *params, &block)
+          filter_attrs_from_set(set_name, *params) do |atr_val, atr_name, set_obj|
+            AFHelpers.each_element(atr_val) do |v|
+              begin
+                yield(v, atr_name, set_obj)
+              rescue NoMethodError, ArgumentError
+                if set_obj.has_annotation?(atr_name, default_key)
+                  set_obj.annotation(atr_name, default_key)
+                else
+                  v
+                end
+              end
+            end
+          end
+        end
+        private :attributes_convert
+
+        # Convert attributes to strings.
+        # 
+        # The attrubutes are taken from the attribute set
+        # called +should_be_strings+.
+        # 
+        # @note If a value of currently processed attribute is an array
+        #  then each element of the array is changed.
+        # 
+        # @return [void]
+        def attributes_to_s
+          attributes_convert(:should_be_strings, :to_s_default) do |v, atr_name, set_obj|
+            if set_obj.has_annotation?(atr_name, :to_s_base)
+              v = 0 if v.nil?
+              if v.method(:to_s).arity != 0
+                v.to_s(set_obj.annotation(atr_name, :to_s_base) || 10)
+              elsif set_obj.has_annotation?(atr_name, :to_s_default)
+                set_obj.annotation(atr_name, :to_s_default)
+              else
+                v
+              end
+            else
+              v.to_s
+            end
+          end
+        end
+        filtering_method  :attributes_to_s, :should_be_strings
+        alias_method      :attributes_to_strings, :attributes_to_s
+        alias_method      :convert_to_strings,    :attributes_to_s
+
+        # This submodule contains class methods used to easily define filter.
+        module ClassMethods
+          # Registers attributes that should be converted.
+          def attributes_to_s(*args)
+            setup_attributes_that :should_be_strings, args,
+              {
+                :to_s_default => [:default, :on_error, :to_s_default],
+                :to_s_base => [:base, :with_base, :to_s_base]
+              }, :to_s_base
+          end
+          alias_method :convert_to_string,      :attributes_to_s
+          alias_method :convert_to_strings,     :attributes_to_s
+          alias_method :converts_to_string,     :attributes_to_s
+          alias_method :converts_to_strings,    :attributes_to_s
+        end # module ClassMethods
+
+        # Convert attributes to integers.
+        # 
+        # The attrubutes are taken from the attribute set
+        # called +should_be_integers+.
+        # 
+        # @note If a value of currently processed attribute is an array
+        #  then each element of the array is changed.
+        # 
+        # @return [void]
+        def attributes_to_i
+          attributes_convert(:should_be_integers, :to_i_default) do |v, atr_name, set_obj|
+            if set_obj.has_annotation?(atr_name, :to_i_base)
+              if v.method(:to_i).arity != 0
+                v.to_i(set_obj.annotation(atr_name, :to_i_base) || 10)
+              elsif set_obj.has_annotation?(atr_name, :to_i_default)
+                set_obj.annotation(atr_name, :to_i_default)
+              else
+                v
+              end
+            else
+              v.to_i
+            end
+          end
+        end
+        filtering_method  :attributes_to_i, :should_be_integers
+        alias_method      :attributes_to_integers, :attributes_to_i
+        alias_method      :convert_to_integers,    :attributes_to_i
+
+        # This submodule contains class methods used to easily define filter.
+        module ClassMethods
+          # Registers attributes that should be converted.
+          def attributes_to_i(*args)
+            setup_attributes_that :should_be_integers, args,
+              {
+                :to_i_default => [:default, :on_error, :to_i_default],
+                :to_i_base => [:base, :with_base, :to_i_base]
+              }, :to_i_base
+          end
+          alias_method :convert_to_integer,     :attributes_to_i
+          alias_method :convert_to_integers,    :attributes_to_i
+          alias_method :converts_to_integer,    :attributes_to_i
+          alias_method :converts_to_integers,   :attributes_to_i
+        end # module ClassMethods
+
+        # Convert attributes to floats.
+        # 
+        # The attrubutes are taken from the attribute set
+        # called +should_be_floats+.
+        # 
+        # @note If a value of currently processed attribute is an array
+        #  then each element of the array is changed.
+        # 
+        # @return [void]
+        def attributes_to_f
+          attributes_convert(:should_be_floats, :to_f_default) { |v| v.to_f }
+        end
+        filtering_method  :attributes_to_f, :should_be_floats
+        alias_method      :attributes_to_floats,  :attributes_to_f
+        alias_method      :convert_to_floats,     :attributes_to_f
+
+        # This submodule contains class methods used to easily define filter.
+        module ClassMethods
+          # Registers attributes that should be converted.
+          def attributes_to_f(*args)
+            setup_attributes_that :should_be_floats, args,
+              { :to_f_default => [:default, :on_error, :to_f_default] },
+              :to_f_default
+          end
+          alias_method :convert_to_float,      :attributes_to_f
+          alias_method :convert_to_floats,     :attributes_to_f
+          alias_method :converts_to_float,     :attributes_to_f
+          alias_method :converts_to_floats,    :attributes_to_f
+        end # module ClassMethods
+
+        # Convert attributes to numbers.
+        # 
+        # The attrubutes are taken from the attribute set
+        # called +should_be_numbers+. It works the same as converting
+        # to floats but uses different attribute set.
+        # 
+        # @note If a value of currently processed attribute is an array
+        #  then each element of the array is changed.
+        # 
+        # @return [void]
+        def attributes_to_numbers
+          attributes_convert(:should_be_numbers, :to_num_default) { |v| v.to_f }
+        end
+        filtering_method  :attributes_to_numbers, :should_be_numbers
+        alias_method      :convert_to_numbers,    :attributes_to_numbers
+        alias_method      :attribute_to_numbers,  :attributes_to_numbers
+
+        # This submodule contains class methods used to easily define filter.
+        module ClassMethods
+          # Registers attributes that should be converted.
+          def attributes_to_numbers(*args)
+            setup_attributes_that :should_be_numbers, args,
+              { :to_num_default => [:default, :on_error, :to_number_default, :to_num_default] },
+              :to_num_default
+          end
+          alias_method :convert_to_number,     :attributes_to_numbers
+          alias_method :convert_to_numbers,    :attributes_to_numbers
+          alias_method :converts_to_number,    :attributes_to_numbers
+          alias_method :converts_to_numbers,   :attributes_to_numbers
+        end # module ClassMethods
+
+        # Convert attributes to rationals.
+        # 
+        # The attrubutes are taken from the attribute set
+        # called +should_be_rationals+.
+        # 
+        # @note If a value of currently processed attribute is an array
+        #  then each element of the array is changed.
+        # 
+        # @return [void]
+        def attributes_to_r
+          attributes_convert(:should_be_rationals, :to_r_default) { |v| v.to_r }
+        end
+        filtering_method  :attributes_to_r, :should_be_rationals
+        alias_method      :attributes_to_rationals,  :attributes_to_r
+        alias_method      :attributes_to_fractions,  :attributes_to_r
+        alias_method      :convert_to_rationals,     :attributes_to_r
+
+        # This submodule contains class methods used to easily define filter.
+        module ClassMethods
+          # Registers attributes that should be converted.
+          def attributes_to_r(*args)
+            setup_attributes_that :should_be_rationals, args,
+              { :to_r_default => [:default, :on_error, :to_r_default] },
+              :to_r_default
+          end
+          alias_method :convert_to_rational,      :attributes_to_r
+          alias_method :convert_to_rationals,     :attributes_to_r
+          alias_method :convert_to_fraction,      :attributes_to_r
+          alias_method :convert_to_fractions,     :attributes_to_r
+          alias_method :converts_to_rational,     :attributes_to_r
+          alias_method :converts_to_rationals,    :attributes_to_r
+          alias_method :converts_to_fraction,     :attributes_to_r
+          alias_method :converts_to_fractions,    :attributes_to_r
+        end # module ClassMethods
+
+        # Convert attributes to boolean values.
+        # 
+        # The attrubutes are taken from the attribute set
+        # called +should_be_boolean+.
+        # 
+        # @note If a value of currently processed attribute is an array
+        #  then each element of the array is changed.
+        # 
+        # @return [void]
+        def attributes_to_b
+          attributes_convert(:should_be_boolean, :to_b_default, :process_blank) { |v| !!v }
+        end
+        filtering_method  :attributes_to_b, :should_be_boolean
+        alias_method      :attributes_to_boolean, :attributes_to_b
+        alias_method      :convert_to_boolean,    :attributes_to_b
+
+        # This submodule contains class methods used to easily define filter.
+        module ClassMethods
+          # Registers attributes that should be converted.
+          def attributes_to_b(*args)
+            setup_attributes_that :should_be_boolean, args,
+              { :to_b_default => [:default, :on_error, :to_b_default] },
+              :to_b_default
+          end
+          alias_method :convert_to_boolean,      :attributes_to_b
+          alias_method :convert_to_booleans,     :attributes_to_b
+          alias_method :converts_to_boolean,     :attributes_to_b
+          alias_method :converts_to_booleans,    :attributes_to_b
+        end # module ClassMethods
+
+      end # module Convert
+
+      include Convert
+
+    end # module Common
+  end # module AttributeFilters
+end # module ActiveModel