attribute-filters 1.3.2 → 1.4.0

data/lib/attribute-filters.rb

@@ -2,7 +2,10 @@
 
 require 'attribute-filters'
 require 'attribute-filters/version'
+require 'attribute-filters/backports'
+
 require 'attribute-filters/attribute_set_enum'
+require 'attribute-filters/attribute_set_annotations'
 require 'attribute-filters/attribute_set'
 require 'attribute-filters/attribute_set_query'
 require 'attribute-filters/attribute_set_attrquery'
@@ -10,6 +13,7 @@ require 'attribute-filters/attribute_set_attrquery'
 require 'attribute-filters/helpers'
 require 'attribute-filters/dsl_sets'
 require 'attribute-filters/dsl_filters'
+require 'attribute-filters/dsl_attr_virtual'
 require 'attribute-filters/common_filters'
 
 if defined? ::Rails

data/lib/attribute-filters/attribute_set.rb

@@ -14,7 +14,9 @@ module ActiveModel
   # This class is a data structure used to store
   # set of attributes.
   class AttributeSet < ::Set
-    include AttributeSetEnumerable
+    include ActiveModel::AttributeSet::Enumerable
+    include ActiveModel::AttributeSet::Annotations
+
     # 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.
@@ -34,5 +36,94 @@ module ActiveModel
       end
     end
     alias_method :<<, :add
+
+    # Merges the elements of the given enumerable
+    # object to the attribute set and returns self.
+    # 
+    # @param o [Enumerable] object to be merged
+    # @return [AttributeSet] current object
+    def merge(o)
+      r = super
+      copy_annotations(o)
+      r
+    end
+
+    # Copies internal structures.
+    # 
+    # @param o [AttributeSet] other set to copy from
+    # @return [AttributeSet] current attribute set
+    def initialize_copy(o)
+      r = super
+      remove_annotations
+      copy_annotations(o)
+      r
+    end
+
+    # Returns a new attribute set containing elements
+    # common to the attribute set and the given enumerable object.
+    # 
+    # @param o [Enumerable] object to intersect with
+    # @return [AttributeSet] intersection of objects
+    def &(o)
+      r = super
+      if r.is_a?(self.class)
+        r.send(:copy_annotations, self)
+        r.send(:copy_annotations, o)
+      end
+      r
+    end
+    alias_method :intersection, :&
+
+    # Deletes the given attribute name from the attribute set
+    # and returns self.
+    # 
+    # @note Use subtract to delete many items at once.
+    # @param o [Symbol,String] attribute name to delete from set
+    # @return [AttributeSet] current attribute set
+    def delete(o)
+      o = o.to_s
+      r = super
+      r.nil? or delete_annotation(o)
+      r
+    end
+
+    # Deletes every attribute of the attribute set
+    # for which the given block evaluates to +true+,
+    # and returns self.
+    # 
+    # @yield [o] block that controlls if an element should be deleted
+    # @yieldparam o [String] current attribute
+    # @return [AttributeSet] current attribute set
+    def delete_if
+      block_given? or return enum_for(__method__)
+      super { |o| r = yield(o) and delete_annotation(o) ; r }
+    end
+
+    # Deletes every attribute of the attribute set
+    # for which the given block evaluates to +false+,
+    # and returns self.
+    # 
+    # @yield [o] block that controlls if an element should be kept
+    # @yieldparam o [String] current attribute
+    # @return [AttributeSet] current attribute set
+    def keep_if
+      block_given? or return enum_for(__method__)
+      super { |o| r = yield(o) or delete_annotation(o) ; r }
+    end
+
+    # Returns a new attribute set containing elements
+    # exclusive between the set and the given enumerable object
+    # (exlusive disjuction).
+    # 
+    # @param o [Enumerable] object to exclusively disjunct with
+    # @return [AttributeSet] resulting set
+    def ^(o)
+      n = self.class.new(o)
+      n.remove_annotations
+      each { |ob| if n.include?(ob) then n.delete(ob) else n.add(ob) end }
+      n.send(:copy_annotations, self)
+      n.send(:copy_annotations, o)
+      n
+    end
   end
 end

data/lib/attribute-filters/attribute_set_annotations.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::AttributeSet annotation methods.
+# Annotations are additional values assigned to attribute names in a set.
+# They are halpful when there is a need to memorize some additional properties or operations.
+
+# This module contains annotations support for AttributeSet.
+# It is included in AttirbuteSet class automatically
+# and allows adding, deleting and removing annotations
+# to certain elements of attribute sets. One element (attribute name)
+module ActiveModel
+  module AttributeFilters
+    module ClassMethods
+      # This method is a wrapper that helps to annotate attributes.
+      # 
+      # @overload annotate_attribute_set(set_name, attribute_name, annotation_key, value)
+      #   @param set_name [Symbol,String] name of a set
+      #   @param attribute_name [Symbol,String] name of annotated attribute
+      #   @param annotation_key [Symbol,String] name of annotation key
+      #   @param value [Object] annotation value
+      #
+      #  @overload annotate_attribute_set(set_name, attribute_name, annotation)
+      #   @param set_name [Symbol,String] name of a set
+      #   @param attribute_name [Symbol,String] name of annotated attribute
+      #   @param annotation [Hash{Symbol => Object}] annotation key => value pairs
+      # 
+      #  @overload annotate_attribute_set(set_name, annotation)
+      #   @param set_name [Symbol,String] name of a set
+      #   @param annotation [Hash{Symbol => Array<Symbol,Object>}] annotation key and value assigned to attribute name
+      # 
+      # @overload annotate_attribute_set(set_name, *annotation)
+      #   @param set_name [Symbol,String] name of a set
+      #   @param annotation [Array<Symbol,Symbol,Object>}] attribute name, annotation key and value
+      # 
+      #  @overload annotate_attribute_set(set_name, annotations)
+      #   @param set_name [Symbol,String] name of a set
+      #   @param annotations [Hash{Symbol => Hash{Symbol => Object}}] annotation key => value pairs for attributes
+      def annotate_attribute_set(*args)
+        first_arg = args.shift
+        if first_arg.is_a?(Hash) # multiple sets defined
+          first_arg.each_pair do |k, v|
+            annotate_attribute_set(k, v, *args)
+          end
+        else
+          atr_name, an_key, an_val = args
+          if atr_name.is_a?(Hash)
+            atr_name.each_pair do |k, v|
+              annotate_attribute_set(first_arg, k, v)
+            end
+          elsif atr_name.is_a?(Array)
+            annotate_attribute_set(first_arg, *atr_name) 
+          elsif an_key.is_a?(Hash)
+            an_key.each_pair do |k, v|
+              annotate_attribute_set(first_arg, atr_name, k, v)
+            end
+          else
+            unless an_key.nil? || atr_name.nil?
+              first_arg = first_arg.to_sym
+              unless __attribute_sets.include?(first_arg)
+                raise ArgumentError, "trying to annotate non-existent set '#{first_arg}'"
+              end
+              __attribute_sets[first_arg].annotate(atr_name, an_key, an_val)
+            end
+          end
+        end
+        nil
+      end
+      alias_method :annotate_attributes_that_are, :annotate_attribute_set
+      alias_method :annotate_attributes_that,     :annotate_attribute_set
+      alias_method :annotate_attributes_are,      :annotate_attribute_set
+      alias_method :annotate_attributes_for,      :annotate_attribute_set
+      alias_method :annotate_attributes_set,      :annotate_attribute_set
+      alias_method :annotate_properties_that,     :annotate_attribute_set
+      alias_method :annotate_attributes,          :annotate_attribute_set
+      alias_method :attribute_set_annotate,       :annotate_attribute_set
+    
+      # Deletes annotaion from a given set
+      # 
+      # @param set_name [String,Symbol] set name  
+      # @param atr_name [String,Symbol] attribute name
+      # @param annotations [Array<String,Symbol>] annotation keys
+      # 
+      # @return [void]
+      def delete_annotation_from_set(set_name, atr_name = nil, *annotations)
+        if set_name.is_a?(Hash)
+          r = {}
+          set_name.each_pair do |k_set, v_attrs|
+            if v_attrs.is_a?(Hash)
+              v_attrs.each_pair do |k_attr, v_annotations|
+                delete_annotation_from_set(k_set, k_attr, *v_annotations)
+              end
+            else
+              delete_annotation_from_set(k_set, v_attrs, *annotations)
+            end
+          end
+        else
+          set_name = set_name.to_sym
+          return unless __attribute_sets.include?(set_name) && atr_name.present?
+          atr_name = atr_name.to_sym
+          __attribute_sets[set_name].delete_annotation(atr_name, *annotations)
+        end
+      end
+      alias_method :delete_annotations_from_set,  :delete_annotation_from_set
+      alias_method :unannotate_set,               :delete_annotation_from_set
+    end # module ClassMethods
+  end # module AttributeFilters
+
+  module AttributeSet::Annotations
+    # Adds an annotation to the given attribute.
+    # 
+    # @param atr_name [String,Symbol] attribute name
+    # @param name [String,Symbol] annotation key
+    # @param value [Object] annotation value
+    # @raise [ArgumentError] when the given attribute name does not exist in a set
+    # @return [void]
+    def annotate(atr_name, name, value)
+      atr_name = atr_name.to_s unless atr_name.blank?
+      unless include?(atr_name)
+        raise ArgumentError, "attribute '#{atr_name}' must exist in order to annotate it"
+      end
+      @annotations ||= Hash.new
+      @annotations[atr_name] ||= Hash.new
+      @annotations[atr_name][name.to_sym] = value
+    end
+    alias_method :add_op,   :annotate
+    alias_method :bind_op,  :annotate
+
+    # Tests if an annotation of the given name exists in a set or if set has annotations.
+    # 
+    # @overload has_annotation?
+    #   Tests if set has any annotations.
+    #   @return [Boolean] +true+ if the current set has any annotations, +false+ otherwise
+    # 
+    # @overload has_annotation?(attribute_name)
+    #   Tests if any annotation key for the attribute of the given name exists in a set.
+    #   @param attribute_name [Symbol,String] name of an attribute
+    #   @return [Boolean] +true+ if the current set has any annotations for +attribute_name+, +false+ otherwise
+    # 
+    # @overload has_annotation?(attribute_name, *annotation_keys)
+    #   Tests if any of the annotation keys for the attribute of the given name exists in a set.
+    #   @param attribute_name [Symbol,String] name of an attribute
+    #   @param annotation_keys [Array<String,Symbol>] annotation key names to check
+    #   @return [Boolean] +true+ if the current set has at least one of the given +annotation_keys+ for +attribute_name+,
+    #    +false+ otherwise
+    def has_annotation?(*args)
+      return false if annotations.nil? || annotations.empty?
+      return true if args.size == 0
+      atr_name = args.shift.to_s
+      a_group = annotations[atr_name]
+      a_group.blank? and return false
+      args.empty? and return true
+      args.any? { |a_name| a_group.key?(a_name.to_sym) }
+    end
+    alias_method :has_annotations?, :has_annotation?
+
+    # Gets an annotation for the specified attribute.
+    # If the second argument is ommited, it returns
+    # all annotations for the specified attribute.
+    # 
+    # @param atr_name [String,Symbol] attribute name
+    # @param annotation_names [Array<String,Symbol>] optional annotation key(s)
+    # @return [Object,Hash,nil] duplicate of annotations hash, value of a single annotation or +nil+ if not found,
+    #  or array of values (filled with +nil+ objects if not found)
+    def annotation(atr_name, *annotation_names)
+      atr_name.present? or return nil
+      has_annotations? or return nil
+      an_group = annotations[atr_name.to_s]
+      return nil if an_group.nil?
+      case annotation_names.size
+      when 0
+        r = Hash.new
+        an_group.each_pair do |k, v|
+          r[k] = v.is_a?(Enumerable) ? v.dup : v
+        end
+        r
+      when 1
+        r = an_group[annotation_names.first.to_sym]
+        r.is_a?(Enumerable) ? r.dup : r
+      else
+        annotation_names.map do |a|
+          r = an_group[a.to_sym]
+          r.is_a?(Enumerable) ? r.dup : r
+        end
+      end
+    end
+    alias_method :get_annotation,   :annotation
+    alias_method :get_annotations,  :annotation
+
+    # Deletes annotations or single annotation key for the given attribute.
+    # If the +annotation+ argument is not given or is +nil+
+    # then all annotation keys for the given attribute name are deleted.
+    # 
+    # @param atr_name [String,Symbol] attribute name
+    # @param annotation [String,Symbol] annotation key
+    # @return [Hash,Object,nil] deleted annotations (hash),
+    #  deleted annotation value or +nil+ if there wasn't anything to delete
+    def delete_annotation(atr_name, annotation = nil)
+      return nil if @annotations.nil? || atr_name.blank?
+      atr_name = atr_name.to_s
+      if annotation.nil?
+        @annotations.delete(atr_name)
+      elsif @annotations.has_key?(atr_name)
+        @annotations[atr_name].delete(annotation.to_sym)
+      else
+        nil
+      end
+    end
+    alias_method :delete_annotations, :delete_annotation
+
+    # Removes all annotations.
+    # @return [void]
+    def remove_annotations
+      @annotations = nil
+    end
+
+    private
+
+    def annotations
+      @annotations
+    end
+
+    def copy_annotations(o)
+      return unless o.is_a?(self.class) && o.has_annotations?
+      @annotations ||= Hash.new
+      o.send(:annotations).each_pair do |atr, annotations_group|
+        if include?(atr)
+          current_group = (@annotations[atr] ||= Hash.new)
+          annotations_group.each_pair do |annotation_name, v|
+            current_group[annotation_name] ||= (v.is_a?(Enumerable) ? v.dup : v)
+          end
+        end
+      end
+    end
+
+    def copy_missing_annotations(from, other)
+      @annotations ||= Hash.new
+      from.each_pair do |atr, annotations_group|
+        if include?(atr) && (other.nil? || !other.has_key?(atr))
+          current_group = (@annotations[atr] ||= Hash.new)
+          annotations_group.each_pair do |annotation_name, v|
+            current_group[annotation_name] ||= (v.is_a?(Enumerable) ? v.dup : v)
+          end
+        end
+      end
+    end
+
+    def remove_different_annotations(other)
+      return unless other.is_a?(self.class) && other.has_annotations?
+      @annotations ||= Hash.new
+      other.send(:annotations).each_pair do |atr, annotations_group|
+        include?(atr) and delete_annotation(atr)
+      end
+    end
+  end # module AttributeSet::Annotations
+end # module ActiveModel

data/lib/attribute-filters/attribute_set_attrquery.rb

@@ -76,11 +76,19 @@ module ActiveModel
           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)
+            @set_object.public_method(method_sym).call(*args, &block)
           end
         end
       end
 
+      # Gets value of current attribute.
+      # If the attribute does not exist it returns +nil+.
+      # 
+      # @return [Object] the value of an attribute
+      def value
+        @am_object.respond_to?(@attribute_name) ? @am_object.public_send(@attribute_name) : nil
+      end
+
       # @private
       def respond_to?(name)
         case name.to_sym
@@ -94,13 +102,6 @@ module ActiveModel
           @set_object.respond_to?(name) || name.to_s.slice(-1,1) == '?'
         end
       end
-
-      # @private
-      def is_a?(klass)
-        super || @set_object.is_a?(klass)
-      end
-      alias_method :kind_of?, :is_a?
-
     end # class AttrQuery
   end # class AttributeSet
 end # module ActiveModel

data/lib/attribute-filters/attribute_set_enum.rb

@@ -4,57 +4,88 @@
 # 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 file contains AttributeSet::Enumerable module and AttributeSet::Enumerator class.
+
+require 'set'
 
 # 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) }
+module ActiveModel
+  class AttributeSet < ::Set
+    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
+        else
+          AttributeSet::Enumerator.new(self, :select)
+        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
       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) }
+
+      # @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
+      end
+      alias_method :map, :collect
+
+      # @private
+      def sort
+        r = ActiveModel::AttributeSet.new(super)
+        r.send(:copy_annotations, self) unless r.empty?
+        r
       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) }
+
+      # @private
+      def sort_by
+        r = ActiveModel::AttributeSet.new(super)
+        r.send(:copy_annotations, self) unless r.empty?
+        r
       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
+
+      # @private
+      def each
+        if block_given?
+          super
+        else
+          AttributeSet::Enumerator.new(self, :each)
+        end
+      end
+    end # module Enumerable
+
+    # This class adds enumerator for AttributeSet elements.
+    class Enumerator < ::Enumerator
+      include ActiveModel::AttributeSet::Enumerable
+    end # class Enumerator
+
+  end # class AttributeSet
+end # module ActiveModel
+
+# @abstract This module is here for compatibility reasons.
+module AttributeSetEnumerable
+  include ActiveModel::AttributeSet::Enumerable
 end
 
-# This class adds enumerator for AttributeSet elements.
-class AttributeSetEnumerator < ::Enumerator
+# @abstract This class is here for compatibility reasons.
+class AttributeSetEnumerator < ActiveModel::AttributeSet::Enumerator
   include AttributeSetEnumerable
 end
-