attribute-filters 1.3.2 → 1.4.0

data/lib/attribute-filters/attribute_set_query.rb

@@ -17,9 +17,26 @@ module ActiveModel
     class Query < BasicObject
       # Creates new query object.
       # 
-      # @param set_object [AttributeSet] attribute set for which the query will be made
-      # @param am_object [Object] model object which has access to attributes (may be an instance of ActiveRecord or similar)
-      def initialize(set_object, am_object)
+      # @overload initialize(am_object)
+      #   Creates new query object and uses empty set as an underlying object.
+      #   @param am_object [Object] model object which has access to attributes (may be an instance of ActiveRecord or similar)
+      #   @return [AttributeSet::Query] query object
+      # 
+      # @overload initialize(set_object, am_object)
+      #   @param set_object [AttributeSet,String,Symbol,Array] attribute set for which the query will be made or
+      #    known attribute set name (symbol or string) existing within the given model or an array uset to create a new set
+      #   @param am_object [Object] model object which has access to attributes (may be an instance of ActiveRecord or similar)
+      #   @return [AttributeSet::Query] query object      
+      def initialize(set_object, am_object = nil)
+        if am_object.nil?
+          am_object = set_object
+          set_object = ::ActiveModel::AttributeSet.new
+        end
+        if set_object.is_a?(::Symbol) || set_object.is_a?(::String)
+          set_object = am_object.class.attribute_set(set_object).dup
+        elsif !set_object.is_a?(::ActiveModel::AttributeSet)
+          set_object = ::ActiveModel::AttributeSet.new(set_object)
+        end
         @set_object = set_object
         @am_object = am_object
         @next_method = nil
@@ -70,7 +87,7 @@ module ActiveModel
           when :invalid?, :is_not_valid?, :any_invalid?, :are_not_valid?, :not_valid?, :is_any_invalid?
             self.any.invalid?
           else
-            r = @set_object.method(method_sym).call(*args, &block)
+            r = @set_object.public_method(method_sym).call(*args, &block)
             return r if r.respond_to?(:__in_as_proxy) || !r.is_a?(::ActiveModel::AttributeSet)
             ::ActiveModel::AttributeSet::Query.new(r, @am_object)
           end
@@ -82,12 +99,12 @@ module ActiveModel
           r = case method_sym
           when :valid?
             @am_object.valid?
-            @set_object.method(m).call(*args) { |atr| not @am_object.errors.has_key?(atr.to_sym) }
+            @set_object.public_method(m).call(*args) { |atr| not @am_object.errors.has_key?(atr.to_sym) }
           when :invalid?
             @am_object.valid?
-            @set_object.method(m).call(*args) { |atr| @am_object.errors.has_key?(atr.to_sym) }
+            @set_object.public_method(m).call(*args) { |atr| @am_object.errors.has_key?(atr.to_sym) }
           else
-            @set_object.method(m).call { |atr| @am_object.send(atr).method(method_sym).call(*args, &block) }
+            @set_object.public_method(m).call { |atr| @am_object.public_send(atr).public_method(method_sym).call(*args, &block) }
           end
           return r if r.respond_to?(:__in_as_proxy) || !r.is_a?(::ActiveModel::AttributeSet)
           ::ActiveModel::AttributeSet::Query.new(r, @am_object)
@@ -114,6 +131,47 @@ module ActiveModel
       end
       alias_method :kind_of?, :is_a?
 
+      # @private
+      def instance_of?(klass)
+        super || @set_object.instance_of?(klass)
+      end
+
+      # @private
+      def instance_eval(*args, &block)
+        @set_object.instance_eval(*args, &block)
+      end
+
+      # @private
+      def instance_exec(*args, &block)
+        @set_object.instance_exec(*args, &block)
+      end
+
+      # Gets values of attributes from current set.
+      # If an attribute does not exist it puts +nil+ in its place.
+      # 
+      # @return [Array] attribute values
+      def values
+        r = []
+        @am_object.for_each_attr_from_set(@set_object,  :process_all,
+                                                        :process_blank,
+                                                        :no_presence_check,
+                                                        :include_missing) { |a| r << a }
+        r
+      end
+
+      # Gets attribute names and their values for attributes from current set.
+      # If an attribute does not exist it puts +nil+ as its value.
+      # 
+      # @return [Hash{String => Object}] attribute names and their values
+      def values_hash
+        r = {}
+        @am_object.for_each_attr_from_set(@set_object,  :process_all,
+                                                        :process_blank,
+                                                        :no_presence_check,
+                                                        :include_missing) { |a, n| r[n] = a }
+        r
+      end
+
       protected
 
       # Queues any method of the given name to be called when next

data/lib/attribute-filters/backports.rb

@@ -0,0 +1,37 @@
+# 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 backports for compatibility with previous Ruby versions.
+
+# @private
+# @abstract This class is here for compatibility reasons.
+class Object
+
+  unless method_defined?(:public_send)
+
+    # @private
+    def public_send(name, *args)
+      unless public_methods.include?(name.to_s)
+        raise NoMethodError.new("undefined method `#{name}' for \"#{self.inspect}\":#{self.class}")
+      end
+      send(name, *args)
+    end
+
+  end
+
+  unless method_defined?(:public_method)
+
+    # @private
+    def public_method(name)
+      unless public_methods.include?(name.to_s)
+        raise NameError.new("undefined method `#{name}' for class `#{self.class}'")
+      end
+      method(name)
+    end
+
+  end
+
+end # class Object

data/lib/attribute-filters/common_filters.rb

@@ -10,145 +10,63 @@
 # @abstract This namespace is shared with ActveModel.
 module ActiveModel
   module AttributeFilters
-    # This module contains common, ready-to-use filtering methods.
-    module Common
 
-      # Strips attributes from leading and trailing spaces.
-      module Strip
-        # Strips attributes from leading and trailing spaces.
-        # 
-        # The attrubutes to be stripped are taken from the attribute set called
-        # +should_be_stripped+. It operates directly on attribute's contents.
-        # 
-        # @return [void]
-        def strip_attributes
-          filter_attrs_from_set(:should_be_stripped) { |atr| atr.strip }
-        end
-      end
+    # This method is a callback method that tries to call all
+    # known filtering methods if they are present.
+    # 
+    # Calling order:
+    # * split_attributes
+    # * join_attributes
+    # * squeeze_attributes
+    # * strip_attributes
+    # * upcase_attributes
+    # * downcase_attributes
+    # * capitalize_attributes
+    # * fully_capitalize_attributes
+    # * titleize_attributes
+    def filter_attributes
+      respond_to?(:split_attributes)            and split_attributes
+      respond_to?(:join_attributes)             and join_attributes
+      respond_to?(:squeeze_attributes)          and squeeze_attributes
+      respond_to?(:strip_attributes)            and strip_attributes
+      respond_to?(:upcase_attributes)           and upcase_attributes
+      respond_to?(:downcase_attributes)         and downcase_attributes
+      respond_to?(:capitalize_attributes)       and capitalize_attributes
+      respond_to?(:fully_capitalize_attributes) and fully_capitalize_attributes
+      respond_to?(:titleize_attributes)         and titleize_attributes
+    end
 
-      # Downcases attributes.
-      module Downcase
-        # Downcases attributes.
-        # 
-        # The attrubutes to be downcased are taken from the attribute set
-        # called +should_be_downcased+. This method is safe to be
-        # used with multibyte strings (containing diacritics).
-        # 
-        # @return [void]
-        def downcase_attributes
-          filter_attrs_from_set(:should_be_downcased) do |atr|
-            atr.mb_chars.downcase.to_s
-          end
-        end
-      end
-
-      # Upcases attributes.
-      module Upcase
-        # Upcases attributes.
-        # 
-        # The attrubutes to be upcased are taken from the attribute set
-        # called +should_be_upcased+. This method is safe to be
-        # used with multibyte strings (containing diacritics).
-        # 
-        # @return [void]
-        def upcase_attributes
-          filter_attrs_from_set(:should_be_upcased) do |atr|
-            atr.mb_chars.upcase.to_s
-          end
-        end
-      end
-
-      # Operates on attributes' case.
-      module Case
-        include Upcase
-        include Downcase
-      end
+    # This module contains common, ready-to-use filtering methods.
+    module Common
 
-      # Capitalizes attributes.
-      module Capitalize
-        # Capitalizes attributes.
-        # 
-        # The attrubutes to be capitalized are taken from the attribute set
-        # called +should_be_capitalized+. This method is safe to be
-        # used with multibyte strings (containing diacritics).
-        # 
-        # @return [void]
-        def capitalize_attributes
-          filter_attrs_from_set(:should_be_capitalized) do |atr|
-            atr.mb_chars.capitalize.to_s
+      # @private
+      module CommonFilter
+        # @private
+        def included(base)
+          if base == ActiveModel::AttributeFilters::Common
+            base::ClassMethods.send(:include, self::ClassMethods)
+          else
+            base.extend ClassMethods
           end
         end
-
-        # Fully capitalizes attributes (capitalizes each word and squeezes spaces).
-        # 
-        # The attrubutes to be fully capitalized are taken from the attribute set
-        # called +should_be_fully_capitalized+ and from set +should_be_titleized+.
-        # This method is safe to be used with multibyte strings (containing diacritics).
-        # 
-        # @return [void]
-        def titleize_with_squeezed_spaces
-          s = attribute_set(:should_be_fully_capitalized) + attribute_set(:should_be_titleized)
-          filter_attrs_from_set(s) do |atr|
-            atr.mb_chars.split(' ').map { |n| n.capitalize }.join(' ')
-          end          
-        end
-        alias_method :fully_capitalize_attributes, :titleize_with_squeezed_spaces
-
       end
 
-      # Squeezes white characters in attributes.
-      module Squeeze
-        # Squeezes white characters in attributes.
-        # 
-        # The attrubutes to be squeezed are taken from the attribute set
-        # called +should_be_squeezed+. This method is safe to be
-        # used with multibyte strings (containing diacritics).
-        # 
-        # @return [void]
-        def squeeze_attributes
-          filter_attrs_from_set(:should_be_squeezed) do |atr|
-            atr.mb_chars.squeeze.to_s
-          end
-        end
-      end
+      extend CommonFilter
 
-      # Squeezes white characters in attributes, removes leading and trailing spaces and newlines.
-      module Squish
-        # Squeezes white characters in attributes, removes leading and trailing spaces and newlines.
-        # 
-        # The attrubutes to be squished are taken from the attribute set
-        # called +should_be_squished+. This method is safe to be
-        # used with multibyte strings (containing diacritics).
-        # 
-        # @return [void]
-        def squish_attributes
-          filter_attrs_from_set(:should_be_squished) do |atr|
-            atr.mb_chars.squish.to_s
-          end
-        end
+      # This module contains class methods used by the DSL
+      # to create keywords for common operations.
+      module ClassMethods
       end
 
-      # Titleizes attributes.
-      module Titleize
-        # Titleizes attributes.
-        # 
-        # The attrubutes to be titleized are taken from the attribute set
-        # called +should_be_titleized+. This method is safe to be
-        # used with multibyte strings (containing diacritics).
-        # 
-        # @return [void]
-        def titleize_attributes
-          filter_attrs_from_set(:should_be_titleized) do |atr|
-            atr.mb_chars.titleize.to_s
-          end
-        end
-      end
+      # Include all default filters
+      # that should be available
+      # when Common module is included.
 
-      include Case;
-      include Strip;
-      include Capitalize;
-      include Titleize;
-      include Squeeze;
+      require 'attribute-filters/common_filters/strip'
+      require 'attribute-filters/common_filters/case'
+      require 'attribute-filters/common_filters/squeeze'
+      require 'attribute-filters/common_filters/split'
+      require 'attribute-filters/common_filters/join'
 
     end # module Common
   end # module AttributeFilters

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

@@ -0,0 +1,159 @@
+# 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::Case module
+# containing ready-to-use filtering method.
+
+# @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 changing the case of letters.
+      module Case
+        extend CommonFilter
+        # Downcases attributes.
+        # 
+        # The attrubutes to be downcased are taken from the attribute set
+        # called +should_be_downcased+. 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.
+        # 
+        # @return [void]
+        def downcase_attributes
+          filter_attrs_from_set(:should_be_downcased) do |atr|
+            AttributeFiltersHelpers.each_element(atr, String) do |v|
+              v.mb_chars.downcase.to_s
+            end
+          end
+        end
+
+        # This submodule contains class methods used to easily define filter.
+        module ClassMethods
+          # Registers attributes that should be downcased.
+          def downcase_attributes(*args)
+            attributes_that(:should_be_downcased, args)
+          end
+          alias_method :downcase_attribute, :downcase_attributes
+        end # module ClassMethods
+
+        # Upcases attributes.
+        # 
+        # The attrubutes to be upcased are taken from the attribute set
+        # called +should_be_upcased+. 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.
+        # 
+        # @return [void]
+        def upcase_attributes
+          filter_attrs_from_set(:should_be_upcased) do |atr|
+            AttributeFiltersHelpers.each_element(atr, String) do |v|
+              v.mb_chars.upcase.to_s
+            end
+          end
+        end
+
+        # This submodule contains class methods used to easily define filter.
+        module ClassMethods
+          # Registers attributes that should be upcased.
+          def upcase_attributes(*args)
+            attributes_that(:should_be_upcased, args)
+          end
+          alias_method :upcase_attribute, :upcase_attributes
+        end # module ClassMethods
+
+        # Titleizes attributes.
+        # 
+        # The attrubutes to be titleized are taken from the attribute set
+        # called +should_be_titleized+. 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.
+        # 
+        # @return [void]
+        def titleize_attributes
+          filter_attrs_from_set(:should_be_titleized) do |atr|
+            AttributeFiltersHelpers.each_element(atr, String) do |v|
+              v.mb_chars.titleize.to_s
+            end
+          end
+        end
+
+        # This submodule contains class methods used to easily define filter.
+        module ClassMethods
+          # Registers attributes that should be titleized.
+          def titleize_attributes(*args)
+            attributes_that(:should_be_titleized, args)
+          end
+          alias_method :titleize_attribute, :titleize_attributes
+        end # module ClassMethods
+
+        # Capitalizes attributes.
+        # 
+        # The attrubutes to be capitalized are taken from the attribute set
+        # called +should_be_capitalized+. 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.
+        # 
+        # @return [void]
+        def capitalize_attributes
+          filter_attrs_from_set(:should_be_capitalized) do |atr|
+            AttributeFiltersHelpers.each_element(atr, String) do |v|
+              v.mb_chars.capitalize.to_s
+            end
+          end
+        end
+
+        # Fully capitalizes attributes (capitalizes each word and squeezes spaces).
+        # 
+        # The attrubutes to be fully capitalized are taken from the attribute set
+        # called +should_be_fully_capitalized+ and from set +should_be_titleized+.
+        # 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.
+        # 
+        # @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|
+              v.mb_chars.split(' ').map { |n| n.capitalize }.join(' ')
+            end
+          end          
+        end
+        alias_method :fully_capitalize_attributes, :titleize_with_squeezed_spaces
+
+        # This submodule contains class methods used to easily define filter.
+        module ClassMethods
+          # Registers attributes that should be capitalized.
+          def capitalize_attributes(*args)
+            attributes_that(:should_be_capitalized, args)
+          end
+          alias_method :capitalize_attribute, :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 :titleize_with_squeezed_spaces, :fully_capitalize_attributes
+        end # module ClassMethods
+      end # module Case
+
+      include Case
+
+    end # module Common
+  end # module AttributeFilters
+end # module ActiveModel