attribute-filters 1.4.0 → 2.0.0

data/lib/attribute-filters/attribute_set_attrquery.rb

@@ -20,11 +20,20 @@ module ActiveModel
       # @param set_object [AttributeSet] attribute set containing set names 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)
       # @param attribute_name [Sting,Symbol] name of attribute the query is made for
-      def initialize(set_object, am_object, attribute_name)
-        @set_object = set_object
+      def initialize(attribute_name = nil, am_object = nil)
+        if am_object.nil?
+          am_object = attribute_name
+          attribute_name = nil
+          unless am_object.included_modules.include?(::ActiveModel::AttributeFilters)
+            raise ::ArgumentError, "incompatible object passed to AttributeSet::AttrQuery (not a model class?)"
+          end
+        end
         @am_object = am_object
-        @attribute_name = attribute_name.to_s
         @next_method = nil
+        unless attribute_name.nil?
+          @set_object = @am_object.class.filter_attribute(attribute_name)
+          @attribute_name = attribute_name.to_s
+        end
       end
 
       # This is a proxy method that causes some calls to be
@@ -50,7 +59,15 @@ module ActiveModel
       # @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
+        method_sym = method_sym.to_sym
+
+        if @attribute_name.nil?
+          @attribute_name = method_sym.to_s
+          @set_object = @am_object.class.filter_attribute(@attribute_name)
+          return self
+        end
+
+        case method_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
@@ -63,16 +80,40 @@ module ActiveModel
           @set_object.include?(*args, &block)
 
         when :accessible?, :is_accessible?
-          @am_object.all_accessible_attributes.include?(@attribute_name)
+          @am_object.class.accessible_attributes.include?(@attribute_name)
 
         when :inaccessible?, :is_inaccessible?
           @am_object.all_inaccessible_attributes.include?(@attribute_name)
 
         when :protected?, :is_protected?
-          @am_object.all_protected_attributes.include?(@attribute_name)
+          @am_object.class.protected_attributes.include?(@attribute_name)
+
+        when :virtual?, :is_virtual?
+          @am_object.class.attribute_filters_virtual.include?(@attribute_name)
+
+        when :semi_real?, :is_semi_real?
+          @am_object.class.treat_as_real.include?(@attribute_name)
+
+        when :valid?, :is_valid?
+          return false unless @am_object.send(:__all_attributes).include?(@attribute_name)
+          return true if @am_object.valid?
+          not @am_object.errors.has_key?(@attribute_name.to_sym)
+
+        when :invalid?, :is_invalid?
+          return true unless @am_object.send(:__all_attributes).include?(@attribute_name)
+          return false if @am_object.valid?
+          @am_object.errors.has_key?(@attribute_name.to_sym)
+
+        when :changed?, :is_changed?, :has_changed?
+          return false unless @am_object.changed? && @am_object.send(:__all_attributes).include?(@attribute_name)
+          @am_object.changes.key?(@attribute_name)
+
+        when :unchanged?, :is_unchanged?, :hasnt_changed?, :not_changed?
+          return true unless @am_object.changed?
+          @am_object.changes.key?(@attribute_name)
 
         else
-          set_name_str = method_sym.to_s.dup
+          set_name_str = method_sym.to_s
           if !@set_object.respond_to?(method_sym) && set_name_str.slice!(/\?\z/) == '?'
             @set_object.include?(set_name_str.to_sym, &block)
           else
@@ -96,7 +137,9 @@ module ActiveModel
              :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,
              :protected?, :is_protected?, :inaccessible?, :is_inaccessible?,
-             :accessible?, :is_accessible?
+             :accessible?, :is_accessible?, :valid?, :is_valid?, :invalid?, :is_invalid?,
+             :virtual?, :is_virtual?, :semi_real?, :is_semi_real?,
+             :changed?, :has_changed?, :is_changed?, :unchanged?, :hasnt_changed?, :is_unchanged?, :not_changed?
           true
         else
           @set_object.respond_to?(name) || name.to_s.slice(-1,1) == '?'

data/lib/attribute-filters/attribute_set_enum.rb

@@ -6,70 +6,76 @@
 # 
 # This file contains AttributeSet::Enumerable module and AttributeSet::Enumerator class.
 
-require 'set'
-
 # This module adds some enumerable properties to AttributeSet objects.
 module ActiveModel
-  class AttributeSet < ::Set
+  class AttributeSet < Hash
+
     module Enumerable
       # @private
-      def select
-        if block_given?
-          ActiveModel::AttributeSet.new.tap do |r|
-            each { |e| r << e if yield(e) }
-            r.send(:copy_annotations, self) unless r.empty?
-          end
+      def select(&block)
+        block_given? or return AttributeSet::Enumerator.new(self, :select)
+        ActiveModel::AttributeSet.new.tap { |r| each_pair { |k, v| r[k] = v if yield(k, v) } }
+      end
+
+      # Selects attributes that have setters and getters.
+      # @param binding [Object] optional object which should have setters and getters (default: the calling context)
+      # @return [AttributeSet::Enumerator, AttributeSet] resulting set or an enumerator if block is not given
+      def select_accessible(binding = nil)
+        if binding.nil?
+          select { |a| respond_to?(a) && respond_to?("#{a}=") }
         else
-          AttributeSet::Enumerator.new(self, :select)
+          select { |a| binding.respond_to?(a) && binding.respond_to?("#{a}=") }
         end
       end
 
       # @private
       def reject
-        if block_given?
-          ActiveModel::AttributeSet.new.tap do |r|
-            each { |e| r << e unless yield(e) }
-            r.send(:copy_annotations, self) unless r.empty?
-          end
-        else
-          AttributeSet::Enumerator.new(self, :reject)
-        end
+        block_given? or return AttributeSet::Enumerator.new(self, :reject)
+        ActiveModel::AttributeSet.new.tap { |r| each_pair { |k, v| r[k] = v unless yield(k, v) } }
       end
 
       # @private
       def collect
-        if block_given?
-          ActiveModel::AttributeSet.new.tap do |r|
-            each { |e| r << yield(e) }
-          end
-        else
-          AttributeSet::Enumerator.new(self, :map)
-        end
+        block_given? ? super { |k, v| yield(k) } : AttributeSet::Enumerator.new(self, :map)
       end
       alias_method :map, :collect
 
       # @private
-      def sort
-        r = ActiveModel::AttributeSet.new(super)
-        r.send(:copy_annotations, self) unless r.empty?
-        r
+      def each
+        block_given? ? each_pair { |k, v| yield(k, v) } : AttributeSet::Enumerator.new(self, :each)
       end
 
       # @private
-      def sort_by
-        r = ActiveModel::AttributeSet.new(super)
-        r.send(:copy_annotations, self) unless r.empty?
-        r
+      def each_pair
+        block_given? ? super : AttributeSet::Enumerator.new(self, :each_pair)
       end
 
-      # @private
-      def each
-        if block_given?
-          super
+      # Iterates through the name and value of each attribute found in a set.
+      # If the attribute has no getter method in the context of the given object, it is not evaluated.
+      # 
+      # @param am_object [Object] active model object
+      # @param no_presence_check [Boolean] optional flag that if +true+ causes enumerator
+      #  not to check if a getter method exists (defaults to +false+ – checks are done)
+      # @return [void,AttributeSet::Enumerator]
+      def each_name_value(am_object, no_presence_check = false)
+        block_given? or return AttributeSet::Enumerator.new(self, :each_name_value, am_object, no_presence_check)
+        if no_presence_check
+          each { |name| yield(name, am_object.public_send(name)) }
         else
-          AttributeSet::Enumerator.new(self, :each)
+          each { |name| yield(name, am_object.public_send(name)) if am_object.respond_to?(name) }
         end
       end
+
+      # @private
+      def sort
+        ActiveModel::AttributeSet[super]
+      end
+
+      # @private
+      def sort_by
+        block_given? ? ActiveModel::AttributeSet[super] : AttributeSet::Enumerator.new(self, :sort_by)
+      end
+
     end # module Enumerable
 
     # This class adds enumerator for AttributeSet elements.

data/lib/attribute-filters/attribute_set_query.rb

@@ -30,14 +30,19 @@ module ActiveModel
       def initialize(set_object, am_object = nil)
         if am_object.nil?
           am_object = set_object
+          unless am_object.included_modules.include?(::ActiveModel::AttributeFilters)
+            raise ::ArgumentError, "incompatible object passed to AttributeSet::Query (not a model class?)"
+          end
           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)
+
+        if set_object.is_a?(::Symbol) || set_object.is_a?(::String)   # global set assigned to model class
+          set_object = am_object.attribute_set_simple(set_object)     #  - duplicated in class method that gets a set
+        elsif !set_object.nil? && !set_object.is_a?(::ActiveModel::AttributeSet) # any other object
+          set_object = ::ActiveModel::AttributeSet.new(set_object)    #  - duplicated in AttributeSet initializer
         end
-        @set_object = set_object
+
+        @set_object = set_object                                      # AttributeSet (assuming it's duplicated if needed)
         @am_object = am_object
         @next_method = nil
       end
@@ -69,42 +74,76 @@ module ActiveModel
       # @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
+        method_sym = method_sym.to_sym
+
+        # set name as a method name
+        if @set_object.nil?
+          @set_object = @am_object.class.attribute_set(method_sym)
+          return self
+        end
+
+        # neutral method
+        case method_sym
         when :are, :is, :be, :should
           return self
         end
-        # Special selectors
+
+        # special selectors
         if @next_method.nil?
-          case method_sym.to_sym
+          case method_sym
+
           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(@set_object, @am_object).
               next_step(:select, args, block)
+
           when :valid?, :is_valid?, :are_valid?, :all_valid?, :are_all_valid?
             self.all.valid?
+
           when :invalid?, :is_not_valid?, :any_invalid?, :are_not_valid?, :not_valid?, :is_any_invalid?
             self.any.invalid?
+
+          when :changed?, :any_changed?, :have_changed?, :have_any_changed?, :is_any_changed?, :has_any_changed?, :has_changed?
+            self.any.changed?
+
+          when :unchanged?, :none_changed?, :nothing_changed?, :is_unchanged?, :are_all_unchanged?,
+               :all_unchanged?, :havent_changed?, :arent_changed?, :are_not_changed?, :none_changed?, :not_changed?
+            self.all.unchanged?
+
           else
             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
         else
-          m, args, block = @next_method
+          n_m, n_args, n_block = @next_method
           @next_method = nil
           # m contains a method that we should call on a set of names (e.g. all? or any?)
           # method_sym contains a method to be called on each attribute from a set (e.g. present?)
           r = case method_sym
+
           when :valid?
             @am_object.valid?
-            @set_object.public_method(m).call(*args) { |atr| not @am_object.errors.has_key?(atr.to_sym) }
+            method_for_each_attr(n_m, *args) { |atr| not @am_object.errors.include?(atr.to_sym) }
+
           when :invalid?
             @am_object.valid?
-            @set_object.public_method(m).call(*args) { |atr| @am_object.errors.has_key?(atr.to_sym) }
+            method_for_each_attr(n_m, *args) { |atr| @am_object.errors.include?(atr.to_sym) }
+
+          when :changed?
+            method_for_each_attr(n_m, *args) { |atr| @am_object.changes.key?(atr) }
+
+          when :unchanged?
+            method_for_each_attr(n_m, *args) { |atr| not @am_object.changes.key?(atr) }
+
           else
-            @set_object.public_method(m).call { |atr| @am_object.public_send(atr).public_method(method_sym).call(*args, &block) }
+            @set_object.public_method(n_m).call(*n_args) do |atr|
+              @am_object.public_send(atr).public_method(method_sym).call(*args, &block)
+            end
+
           end
           return r if r.respond_to?(:__in_as_proxy) || !r.is_a?(::ActiveModel::AttributeSet)
           ::ActiveModel::AttributeSet::Query.new(r, @am_object)
@@ -120,6 +159,11 @@ module ActiveModel
           true
         when :valid?, :is_valid?, :are_valid?, :all_valid?, :are_all_valid?
           true
+        when :changed?, :any_changed?, :have_changed?, :have_any_changed?, :is_any_changed?, :has_any_changed?, :has_changed?
+          true
+        when :unchanged?, :none_changed?, :nothing_changed?, :is_unchanged?, :are_all_unchanged?,
+             :all_unchanged?, :havent_changed?, :arent_changed?, :are_not_changed?, :none_changed?, :not_changed?
+          true
         else
           @set_object.respond_to?(name)
         end
@@ -185,6 +229,12 @@ module ActiveModel
         @next_method = [method_name, args, block]
         return self
       end
+
+      private
+
+      def method_for_each_attr(m, *args, &block)
+        @set_object.public_method(m).call(*args, &block)
+      end
     end # class Query
   end # class AttributeSet
 end # module ActiveModel

data/lib/attribute-filters/backports.rb

@@ -11,7 +11,6 @@
 class Object
 
   unless method_defined?(:public_send)
-
     # @private
     def public_send(name, *args)
       unless public_methods.include?(name.to_s)
@@ -19,11 +18,9 @@ class Object
       end
       send(name, *args)
     end
-
   end
 
   unless method_defined?(:public_method)
-
     # @private
     def public_method(name)
       unless public_methods.include?(name.to_s)
@@ -31,7 +28,42 @@ class Object
       end
       method(name)
     end
-
   end
 
 end # class Object
+
+# @private
+# @abstract This class is here for compatibility reasons.
+class Hash
+
+  # @private
+  unless method_defined?(:deep_merge)
+    def deep_merge(o)
+      dup.deep_merge!(o)
+    end
+  end
+
+  # @private
+  unless method_defined?(:deep_merge!)
+    def deep_merge!(other_hash)
+      other_hash.each_pair do |k, ov|
+        my_v = self[k]
+        self[k] = my_v.is_a?(Hash) && ov.is_a?(Hash) ? my_v.deep_merge(ov) : ov
+      end
+      self
+    end
+  end
+
+  # @private
+  unless method_defined?(:deep_dup)
+    def deep_dup
+      duplicate = self.dup
+      duplicate.each_pair do |k, ov|
+        my_v = duplicate[k]
+        duplicate[k] = my_v.is_a?(Hash) && ov.is_a?(Hash) ? my_v.deep_dup : ov
+      end
+      duplicate
+    end
+  end
+
+end # class Hash

data/lib/attribute-filters/common_filters.rb

@@ -11,63 +11,109 @@
 module ActiveModel
   module AttributeFilters
 
-    # 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
+    # This module holds method for marking methods as filters.
+    module FilteringRegistration
+      # This method marks a method as filtering method
+      # and associates it with the given name of an attribute set it uses.
+      # 
+      # @param method_name [Symbol] name of a method
+      # @param set_name [Symbol] name of an attribute set
+      # @return [void]
+      def filtering_method(method_name, set_name)
+        set_name = set_name.to_sym
+        return unless method_defined?(method_name)
+        f = (@__filtering_sets ||= MetaSet.new)
+        f[set_name] = method_name unless f.key?(set_name)
+        nil
+      end
+      alias_method :has_filtering_method, :filtering_method
+
+    end # module FilteringRegistration
 
     # This module contains common, ready-to-use filtering methods.
     module Common
-
       # @private
       module CommonFilter
+        include FilteringRegistration
+
         # @private
         def included(base)
-          if base == ActiveModel::AttributeFilters::Common
-            base::ClassMethods.send(:include, self::ClassMethods)
+
+          # merge filtering sets from filtering modules to models
+          fs = @__filtering_sets
+          base.class_eval { (@__filtering_sets ||= MetaSet.new).merge!(fs) } unless fs.nil?
+
+          if  base.const_defined?(:ClassMethods)  &&
+              base.instance_of?(::Module)         &&
+              base.const_get(:ClassMethods).instance_of?(::Module)
+
+            # If we're here then this module was included by some other module
+            # (one of our own filtering submodules).
+            base.class_eval <<-EVAL
+              unless singleton_class.method_defined?(:included)
+                def self.included(base)
+                  fs = @__filtering_sets
+                  base.class_eval { (@__filtering_sets ||= MetaSet.new).merge!(fs) } unless fs.nil?
+                  base.extend ClassMethods
+                end
+              end
+              module ClassMethods
+                include #{self.name}::ClassMethods
+              end
+            EVAL
+
           else
+
+            # If we're here then this module was included
+            # by some model or other class.
             base.extend ClassMethods
+
           end
         end
-      end
-
-      extend CommonFilter
+      end # module CommonFilter
 
       # This module contains class methods used by the DSL
-      # to create keywords for common operations.
+      # to create keywords for common filtering operations.
+      # These keywords can be used in filtering submodules
+      # and in any model that includes them.
       module ClassMethods
       end
 
+      extend CommonFilter
+
       # Include all default filters
       # that should be available
       # when Common module is included.
-
-      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'
+      Dir[File.join(File.dirname(__FILE__), 'common_filters', '*.rb')].each do |f|
+        require f
+      end
 
     end # module Common
+
+    # This method is a callback method that tries to call all
+    # known filtering methods if they are in use.
+    # 
+    # Calling order depends on sets registering order.
+    # 
+    # @return [nil]
+    def filter_attributes
+      as, fs = *self.class.class_eval { [__attribute_sets, @__filtering_sets] }
+      return if fs.blank? || as.blank?
+      as.each_pair { |set_name, o| send(fs[set_name]) if fs.has_key?(set_name) }
+      nil
+    end
+
+    # Gets a list of filtering hooks that are in use.
+    # 
+    # @return [MetaSet{Symbol => Symbol}] a meta set of filtering methods and associated sets
+    def filtering_methods
+      f = self.class.instance_variable_get(:@__filtering_sets)
+      f.nil? ? ActiveModel::MetaSet.new : f.dup
+    end
+
+    module ClassMethods
+      include FilteringRegistration
+    end
+
   end # module AttributeFilters
 end # module ActiveModel