attribute-filters 1.1.2 → 1.1.3

data/lib/attribute-filters.rb

@@ -2,12 +2,15 @@
 
 require 'attribute-filters'
 require 'attribute-filters/version'
+require 'attribute-filters/attribute_set_enum'
 require 'attribute-filters/attribute_set'
 require 'attribute-filters/attribute_set_query'
+require 'attribute-filters/attribute_set_attrquery'
 
 require 'attribute-filters/helpers'
 require 'attribute-filters/dsl_sets'
 require 'attribute-filters/dsl_filters'
+require 'attribute-filters/common_filters'
 
 if defined? ::Rails
   require 'attribute-filters/railtie'

data/lib/attribute-filters/active_model_insert.rb

@@ -8,6 +8,7 @@
 
 require 'active_model'
 
+# @abstract This namespace is shared with ActveModel.
 module ActiveModel
 
   if defined?(AttributeMethods)
@@ -30,7 +31,7 @@ module ActiveModel
         singleton_class.send(:alias_method, :included, :included_with_attribute_methods)
         #singleton_class.send(:alias_method_chain, :included, :attribute_methods)
       end
-  
+
     end # ActiveModel::AttributeMethods.class_eval
 
   end # if defined?(AttributeMethods)

data/lib/attribute-filters/attribute_set.rb

@@ -12,7 +12,27 @@ require 'set'
 # @abstract This namespace is shared with ActveModel.
 module ActiveModel
   # This class is a data structure used to store
-  # sets of attributes.
+  # set of attributes.
   class AttributeSet < ::Set
+    include AttributeSetEnumerable
+    # Adds the given object to the set and returns self.
+    # If the object is already in the set, returns nil.
+    # If the object is an array it adds each element of the array.
+    # The array is not flattened so if it contains other arrays
+    # then they will be added as the arrays.
+    # When adding an array the returning value is also an array,
+    # which contains elements that were successfuly added to set
+    # and didn't existed there before.
+    # 
+    # @param o [Object,Array] object to be added to set or array of objects
+    # @return [AttributeSet,nil]
+    def add(o)
+      if o.is_a?(Array)
+        o.map{ |e| super(e) }.compact
+      else
+        super
+      end
+    end
+    alias_method :<<, :add
   end
 end

data/lib/attribute-filters/attribute_set_attrquery.rb

@@ -0,0 +1,74 @@
+# 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::AttributeSet::AttrQuery class
+# used to interact with attribute sets containing set names.
+
+# @abstract This namespace is shared with ActveModel.
+module ActiveModel
+  class AttributeSet
+    # This class contains proxy methods used to interact with
+    # AttributeSet instances. It's responsible for all of the DSL magic
+    # that allows sweet constructs like:
+    #   the_attribute(:x).is.in_set?
+    class AttrQuery < Query
+      # This is a proxy method that causes some calls to be
+      # intercepted. Is allows to create semi-natural
+      # syntax when querying attribute sets containing set names.
+      # 
+      # When the called method name ends with question mark then
+      # its name is considered to be an attribute set name that
+      # should be tested for presence of the attribute. To use
+      # that syntax you have to be sure that there is no already
+      # defined method for AttributeSet object which name ends
+      # with question mark. Otherwise you may get false positives
+      # or a strange errors when trying to test if attribute belongs
+      # to a set. The real method call will override your check.
+      # 
+      # @example
+      #   the_attribute(:some_attribute).is.in?(:some_set)
+      #   the_attribute(:some_attribute).list.sets
+      #   the_attribute(:some_attribute).is.in.a.set.that?(:should_be_downcased)
+      #   the_attribute(:some_attribute).should_be_downcased?
+      # 
+      # @param method_sym [Symbol,String] name of method that will be queued or called on a set
+      # @param args [Array] optional arguments to be passed to a method call
+      # @yield optional block to be passed to a method call
+      def method_missing(method_sym, *args, &block)
+        case method_sym.to_sym
+        when :are, :is, :one, :is_one, :in, :list, :be, :should,
+             :the, :a, :sets, :in_sets, :set, :in_a_set, :in_set, :belongs_to
+          self
+        when :belongs_to?, :in?, :in_set?, :in_a_set?, :in_the_set?,
+             :the_set?, :set?, :is_one_that?, :one_that?, :that?
+          if args.present? && args.is_a?(::Array)
+            args = args.map{ |a| a.to_sym if a.respond_to?(:to_sym) }
+          end
+          @set_object.include?(*args, &block)
+        else
+          set_name_str = method_sym.to_s.dup
+          if !@set_object.respond_to?(method_sym) && set_name_str.slice!(/\?\z/) == '?'
+            @set_object.include?(set_name_str.to_sym, &block)
+          else
+            @set_object.method(method_sym).call(*args, &block)
+          end
+        end
+      end
+
+      # @private
+      def respond_to?(name)
+        case name.to_sym
+        when :are, :is, :one, :is_one, :in, :list, :be, :should, :the, :a, :sets, :in_sets,
+             :set, :in_a_set, :in_set, :in?, :in_set?, :in_a_set?, :in_the_set?, :the_set?, :set?,
+             :is_one_that?, :one_that?, :that?, :belongs_to?, :belongs_to
+          true
+        else
+          @set_object.respond_to?(name) || name.to_s.slice(-1,1) == '?'
+        end
+      end
+    end # class AttrQuery
+  end # class AttributeSet
+end # module ActiveModel

data/lib/attribute-filters/attribute_set_enum.rb

@@ -0,0 +1,60 @@
+# 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 AttributeSetEnumerable module and AttributeSetEnumerator class.
+
+# This module adds some enumerable properties to AttributeSet objects.
+module AttributeSetEnumerable
+  # @private
+  def select
+    if block_given?
+      ActiveModel::AttributeSet.new.tap do |r|
+        each { |e| r << e if yield(e) }
+      end
+    else
+      AttributeSetEnumerator.new(self, :select)
+    end
+  end
+
+  # @private
+  def reject
+    if block_given?
+      ActiveModel::AttributeSet.new.tap do |r|
+        each { |e| r << e unless yield(e) }
+      end
+    else
+      AttributeSetEnumerator.new(self, :reject)
+    end
+  end
+
+  # @private
+  def collect
+    if block_given?
+      ActiveModel::AttributeSet.new.tap do |r|
+        each { |e| r << yield(e) }
+      end
+    else
+      AttributeSetEnumerator.new(self, :map)
+    end
+  end
+  alias_method :map, :collect
+
+  # @private
+  def sort
+    ActiveModel::AttributeSet.new(super)
+  end
+
+  # @private
+  def sort_by
+    ActiveModel::AttributeSet.new(super)
+  end
+end
+
+# This class adds enumerator for AttributeSet elements.
+class AttributeSetEnumerator < ::Enumerator
+  include AttributeSetEnumerable
+end
+

data/lib/attribute-filters/attribute_set_query.rb

@@ -7,6 +7,7 @@
 # This file contains ActiveModel::AttributeSet::Query class
 # used to interact with attribute sets.
 
+# @abstract This namespace is shared with ActveModel.
 module ActiveModel
   class AttributeSet
     # This class contains proxy methods used to interact with
@@ -16,15 +17,15 @@ module ActiveModel
     class Query < BasicObject
       # Creates new query object.
       # 
-      # @param attribute_set_object [AttributeSet] attribute set for which the query will be made
+      # @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(attribute_set_object, am_object)
-        @attribute_set = attribute_set_object
+      def initialize(set_object, am_object)
+        @set_object = set_object
         @am_object = am_object
         @next_method = nil
       end
 
-      # This is proxy method that causes some calls to be
+      # This is a proxy method that causes some calls to be
       # queued to for the next call. Is allows to create semi-natural
       # syntax when querying attribute sets.
       # 
@@ -49,26 +50,41 @@ module ActiveModel
       # @param method_sym [Symbol,String] name of method that will be queued or called on attribute set
       # @param args [Array] optional arguments to be passed to a method call or to a queued method call
       # @yield optional block to be passed to a method call or to a queued method call
+      # @return [Object] the returned value is passed back from called method
       def method_missing(method_sym, *args, &block)
         case method_sym.to_sym
         when :are, :is, :be, :should
           return self
         end
-        if @method_to_call.nil?
+        if @next_method.nil?
           case method_sym.to_sym
-          when :all, :any
-            ::ActiveModel::AttributeSet::Query.new(@attribute_set, @am_object).   # new obj. == thread-safe
+          when :all, :any, :none, :one
+            ::ActiveModel::AttributeSet::Query.new(@set_object, @am_object).   # new obj. == thread-safe
               next_step(method_sym.to_s << "?", args, block)
           when :list, :show
-            ::ActiveModel::AttributeSet::Query.new(@attribute_set, @am_object).
+            ::ActiveModel::AttributeSet::Query.new(@set_object, @am_object).
               next_step(:select, args, block)
           else
-            @attribute_set.method(method_sym).call(*args, &block)
+            r = @set_object.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
         else
-          method_sym, args, block = @next_method
+          m, args, block = @next_method
           @next_method = nil
-          @attribute_set.method(m).call { |a| @am_object[a].method(method_sym).call(*args, &block) }
+          r = @set_object.method(m).call { |a| @am_object[a].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
+      end
+
+      # @private 
+      def respond_to?(name)
+        case name.to_sym
+        when :are, :is, :be, :should, :all, :any, :none, :one, :list, :show, :__in_as_proxy
+          true
+        else
+          @set_object.respond_to?(name)
         end
       end
 

data/lib/attribute-filters/common_filters.rb

@@ -1,4 +1,79 @@
+# 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 module
+# containing ready-to-use, common filtering methods.
 
+# @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.
+      # 
+      # 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
+        call_attrs_from_set(:should_be_stripped) { |atr| atr.strip! }
+      end
 
-# todo: manually included module with common filters
+      # 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
 
+      # 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
+
+      # Capitalize 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
+        end
+      end
+
+      # Fully capitalize attributes (capitalize each word).
+      # 
+      # The attrubutes to be fully capitalized are taken from the attribute set
+      # called +should_be_fully_capitalized+. This method is safe to be
+      # used with multibyte strings (containing diacritics).
+      # 
+      # @return [void]
+      def fully_capitalize_attributes
+        filter_attrs_from_set(:should_be_fully_capitalized) do |atr|
+          atr.mb_chars.split(' ').map { |n| n.capitalize }.join(' ')
+        end
+      end
+
+    end # module Common
+  end # module AttributeFilters
+end # module ActiveModel

data/lib/attribute-filters/dsl_filters.rb

@@ -6,6 +6,7 @@
 # 
 # This file contains modules with methods that create DSL for managing attribute filters.
 
+# @abstract This namespace is shared with ActveModel.
 module ActiveModel
   module AttributeFilters
     # @private
@@ -20,8 +21,6 @@ module ActiveModel
     # to the given attribute set.
     # 
     # @param set_name [AttributeSet] set of attributes used to get attributes
-    # @param alter_mode [Boolean] if set then the existence
-    #   of attribute is checked by testing if writer is defined; otherwise the reader is checked
     # @param process_all [Boolean] if set then all the attributes from the attribute set are selected,
     #   not just attributes that has changed
     # @param no_presence_check [Boolean] if set then the checking whether attribute exists will be
@@ -30,9 +29,13 @@ module ActiveModel
     def attributes_to_filter(set_name, process_all = false, no_presence_check = false)
       atf = attribute_set(set_name)
       if process_all
-        no_presence_check ? atf : atf & attributes.keys
+        no_presence_check ? atf : atf & (__vatrf(no_presence_check) + attributes.keys)
       else
-        atf & changed_attributes.keys
+        if self.class.filter_virtual_attributes_that_changed?
+          atf & changes.keys
+        else
+          atf & (__vatrf(no_presence_check)  + changes.keys)
+        end
       end
     end
 
@@ -46,7 +49,7 @@ module ActiveModel
     #   It's major purpose is to create filtering methods.
     #   
     #   Only the
-    #   {http://rubydoc.info/gems/activemodel/ActiveModel/Dirty#changed_attributes-instance_method changed attributes}
+    #   {http://rubydoc.info/gems/activemodel/ActiveModel/Dirty#changes-instance_method changed attributes/properties}
     #   are selected, unless the +process_all+ flag is
     #   given. If that flag is given then presence of each attribute is verified,
     #   unless the +no_presence_check+ flag is also set. Attributes with empty or unset values
@@ -108,7 +111,7 @@ module ActiveModel
     #   It's major purpose is to iterate through attributes and/or work directly with their values.
     #   
     #   Only the
-    #   {http://rubydoc.info/gems/activemodel/ActiveModel/Dirty#changed_attributes-instance_method changed attributes}
+    #   {http://rubydoc.info/gems/activemodel/ActiveModel/Dirty#changes-instance_method changed attributes/properties}
     #   are selected, unless the +process_all+ flag is
     #   given. If that flag is given then presence of each attribute is verified,
     #   unless the +no_presence_check+ flag is also set. Attributes with
@@ -157,8 +160,56 @@ module ActiveModel
     alias_method :for_attributes_that_are,  :for_each_attr_from_set
     alias_method :for_attributes_which_are, :for_each_attr_from_set
 
+    module ClassMethods
+      # @overload treat_as_real(*attributes)
+      #   Informs Attribute Filters that the given attributes
+      #   should be treated as present, even they are not in
+      #   attributes hash provided by ORM or ActiveModel.
+      #   Useful when operating on virtual attributes.
+      #   
+      #   @param attributes [Array] list of attribute names
+      #   @return [void]
+      # 
+      # @overload treat_as_real()
+      #   Gets the memorized attribute names that should be
+      #   treated as existing.
+      #   
+      #   @return [AttributeSet] set of attribute name
+      def treat_as_real(*args)
+        return __treat_as_real.dup if args.blank?
+        __treat_as_real << args.flatten.compact.map { |atr| atr.to_s }
+        nil
+      end
+      alias_method :treat_attribute_as_real,  :treat_as_real
+      alias_method :treat_attributes_as_real, :treat_as_real
+
+      # Sets the internal flag that causes to check virtual attributes
+      # for changes when selecting attributes for filtering.
+      # @return [void]
+      def filter_virtual_attributes_that_have_changed
+        @filter_virtual_attributes_that_changed = true
+      end
+      alias_method :filter_virtual_attributes_that_changed, :filter_virtual_attributes_that_have_changed
+      alias_method :filter_changed_virtual_attributes,      :filter_virtual_attributes_that_have_changed
+
+      # Gets the internal flag that causes to check virtual attributes
+      # for changes when selecting attributes for filtering.
+      # @return [Boolean] +true+ if the virtual attributes should be checked for a change, +false+ otherwise
+      def filter_virtual_attributes_that_changed?
+        !!@filter_virtual_attributes_that_changed
+      end
+
+      private
+
+      def __treat_as_real
+        @__treat_as_real ||= ActiveModel::AttributeSet.new
+      end
+
+    end # module ClassMethods
+
     private
 
+    # Applies operations to elements from set.
     def operate_on_attrs_from_set(set_name, alter_mode, *args, &block)
       flags             = AttributeFiltersHelpers.process_flags(args)
       process_all       = flags[:process_all]
@@ -194,5 +245,15 @@ module ActiveModel
       end
     end
 
+    private
+
+    # Helper that collects virtual attributes that
+    # have setters and getters.
+    def __vatrf(no_presence_check = false)
+      tar = self.class.send(:__treat_as_real)
+      return tar if no_presence_check || tar.empty?
+      tar.select { |a| respond_to?(a) && respond_to?("#{a}=") }
+    end
+
   end # module AttributeFilters
 end # module ActiveModel