attribute-filters 1.4.0 → 2.0.0

data/lib/attribute-filters.rb

@@ -3,14 +3,15 @@
 require 'attribute-filters'
 require 'attribute-filters/version'
 require 'attribute-filters/backports'
+require 'attribute-filters/helpers'
 
 require 'attribute-filters/attribute_set_enum'
-require 'attribute-filters/attribute_set_annotations'
 require 'attribute-filters/attribute_set'
+require 'attribute-filters/meta_set'
+require 'attribute-filters/attribute_set_annotations'
 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/dsl_attr_virtual'
@@ -21,3 +22,4 @@ if defined? ::Rails
 else
   require 'attribute-filters/active_model_insert'
 end
+

data/lib/attribute-filters/attribute_set.rb

@@ -7,15 +7,25 @@
 # This file contains ActiveModel::AttributeSet class
 # used to interact with attribute sets.
 
-require 'set'
-
 # @abstract This namespace is shared with ActveModel.
 module ActiveModel
   # This class is a data structure used to store
   # set of attributes.
-  class AttributeSet < ::Set
+  class AttributeSet <  Hash
     include ActiveModel::AttributeSet::Enumerable
-    include ActiveModel::AttributeSet::Annotations
+
+    # Helpers module shortcut
+    AFHelpers = ActiveModel::AttributeFilters::AttributeFiltersHelpers
+
+    # Creates a new instance of attribute set.
+    # 
+    # @return [AttributeSet] an AttributeSet object
+    def initialize(*args)
+      return super if args.count == 0
+      r = super()
+      add(args)
+      r
+    end
 
     # Adds the given object to the set and returns self.
     # If the object is already in the set, returns nil.
@@ -26,104 +36,165 @@ module ActiveModel
     # 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
+    # @param args [Array<Object,Hash,Array,Enumerable>] object(s) to be added to set
+    # @return [AttributeSet] current attribute set object
+    def add(*args)
+      args.flatten.each do |a|
+        if a.is_a?(Hash)
+          deep_merge!(a)
+        elsif a.is_a?(::Enumerable)
+          a.each { |e| self[e] = true unless e.blank? }
+        else
+          self[a] = true
+        end
       end
+      self
     end
     alias_method :<<, :add
 
-    # Merges the elements of the given enumerable
-    # object to the attribute set and returns self.
+    # @private
+    def to_a
+      keys
+    end
+
+    # @private
+    def to_set
+      keys.to_set
+    end
+
+    # Adds two sets by deeply merging their contents.
+    # If any value stored in one set under conflicting key
+    # is +true+, +false+ or +nil+ then value is taken from other set.
+    # If one of the conflicting values is a kind of Hash and
+    # the other is not the it's converted to a hash which is merged in.
+    # Otherwise the left value wins.
     # 
-    # @param o [Enumerable] object to be merged
-    # @return [AttributeSet] current object
-    def merge(o)
-      r = super
-      copy_annotations(o)
+    # @return [AttributeSet] resulting set
+    def +(o)
+      my_class = self.class
+      o = my_class.new(o) unless o.is_a?(Hash)
+      r = my_class.new
+      (keys + o.keys).uniq.each do |k|
+        if self.key?(k) && o.key?(k)
+          r[k] = merge_set(self[k], o[k]) { |a, b| a + b }
+        else
+          r[k] = AFHelpers.safe_dup(self[k] || o[k])
+        end
+      end
       r
     end
 
-    # Copies internal structures.
+    # Subtracts the given set from the current one
+    # by removing all the elements that have the same keys.
     # 
-    # @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
+    # @return [AttributeSet] resulting set
+    def -(o)
+      o = self.class.new(o) unless o.is_a?(Hash)
+      reject { |k, v| o.include?(k) }
     end
 
     # Returns a new attribute set containing elements
     # common to the attribute set and the given enumerable object.
+    # Annotations from other set that aren't in this set are copied.
     # 
     # @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)
+      my_class = self.class
+      o = my_class.new(o) unless o.is_a?(Hash)
+      r = my_class.new
+      each_pair do |k, my_v|
+        if o.include?(k)
+          r[k] = merge_set(my_v, o[k]) { |a, b| a & b }
+        end
       end
       r
     end
     alias_method :intersection, :&
+    alias_method :intersect, :&
 
-    # Deletes the given attribute name from the attribute set
-    # and returns self.
+    # Returns a new attribute set containing elements
+    # exclusive between the set and the given enumerable object
+    # (exclusive disjuction).
     # 
-    # @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)
+    # @param o [Enumerable] object to exclusively disjunct with
+    # @return [AttributeSet] resulting set
+    def ^(o)
+      my_class = self.class
+      o = my_class.new(o) unless o.is_a?(Hash)
+      r = my_class.new
+      (o.keys + keys).uniq.each do |k|
+        if key?(k)
+          next if o.key?(k)
+          src = self[k]
+        elsif o.key?(k)
+          src = o[k]
+        end
+        r[k] = AFHelpers.safe_dup(src)
+      end
       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 }
+    # @private
+    def inspect
+      ids = (Thread.current[:attributefilters] ||= [])
+      ids.include?(object_id) and return sprintf('#<%s: {...}>', self.class.name)
+      begin
+        ids << object_id
+        r = []
+        each_pair { |k, v| r << (v.is_a?(Hash) ? "#{k}+" : k) }
+        return sprintf('#<%s: {%s}>', self.class, r.inspect[1..-2])
+      ensure
+        ids.pop
+      end
     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 }
+    private
+
+    # Internal method for merging sets.
+    def merge_set(my_v, ov, my_class = self.class)
+      if my_v.is_a?(Hash)
+        if ov.is_a?(Hash)
+          my_v = my_class.new(my_v) unless my_v.is_a?(my_class)
+          ov = my_class.new(ov) unless ov.is_a?(my_class)
+          return yield(my_v, ov)
+        else
+          a_hash = my_v
+          a_other = ov
+        end
+      else
+        if ov.is_a?(Hash)
+          a_hash = ov
+          a_other = my_v
+        else
+          return my_v === true ? ov : my_v
+        end
+      end
+      if a_other === true || a_other === false || a_other.nil?
+        a_hash
+      else
+        a_hash.deep_merge(my_class.new(ov))
+      end
     end
+  end # class AttributeSet
 
-    # 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
+  # This is a kind of AttributeSet class
+  # but its purpose it so store other information
+  # than attribute names.
+  class MetaSet < AttributeSet
+    def initialize(*args)
+      Hash.instance_method(:initialize).bind(self).call(*args)
+    end
+    def inspect(*args)
+      Hash.instance_method(:inspect).bind(self).call(*args)
+    end
+    # Internal method for merging sets.
+    def merge_set(my_v, ov, my_class = self.class)
+      if my_v.is_a?(my_class) && ov.is_a?(my_class)
+        my_v.deep_merge(ov)
+      else
+        my_v
+      end
     end
   end
-end
+end # module ActiveModel

data/lib/attribute-filters/attribute_set_annotations.rb

@@ -22,26 +22,31 @@ module ActiveModel
       #   @param attribute_name [Symbol,String] name of annotated attribute
       #   @param annotation_key [Symbol,String] name of annotation key
       #   @param value [Object] annotation value
+      #   @return [nil]
       #
       #  @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
+      #   @return [nil]
       # 
       #  @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
+      #   @return [nil]
       # 
       # @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
+      #   @return [nil]
       # 
       #  @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
+      #   @return [nil]
       def annotate_attribute_set(*args)
         first_arg = args.shift
-        if first_arg.is_a?(Hash) # multiple sets defined
+        if first_arg.is_a?(Hash)                  # multiple sets defined
           first_arg.each_pair do |k, v|
             annotate_attribute_set(k, v, *args)
           end
@@ -60,7 +65,7 @@ module ActiveModel
           else
             unless an_key.nil? || atr_name.nil?
               first_arg = first_arg.to_sym
-              unless __attribute_sets.include?(first_arg)
+              unless __attribute_sets.key?(first_arg)
                 raise ArgumentError, "trying to annotate non-existent set '#{first_arg}'"
               end
               __attribute_sets[first_arg].annotate(atr_name, an_key, an_val)
@@ -69,22 +74,78 @@ module ActiveModel
         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
-    
+      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 :annotates_attributes_that_are,  :annotate_attribute_set
+      alias_method :annotates_attributes_that,      :annotate_attribute_set
+      alias_method :annotates_attributes_are,       :annotate_attribute_set
+      alias_method :annotates_attributes_for,       :annotate_attribute_set
+      alias_method :annotates_attributes_set,       :annotate_attribute_set
+      alias_method :annotates_properties_that,      :annotate_attribute_set
+      alias_method :annotates_attributes,           :annotate_attribute_set
+      alias_method :attribute_set_annotate,         :annotate_attribute_set
+
+      # Helps in adding attributes to sets with annotations used to store parameters.
+      # 
+      # @param set_name [Symbol,String] name of a set
+      # @param param_defs [Hash{Symbol => Array<Symbol,String>}]
+      # @param default_param [Symbol,String,nil]
+      # @param attribute_defs [Hash{Symbol => Object}, Array<Symbol,String>]
+      # @return [nil]
+      # @example
+      #   setup_attributes_set  :should_be_filled,
+      #                         { 'atr_name'  => { :with => 'x', :fill_any => true }, :other_atr => 'text' },
+      #                         { :fill_value => [ :with, :fill_with, :value, :content ] },
+      #                         :fill_value
+      def setup_attributes_set(set_name, attribute_defs, param_defs = {}, default_param = nil)
+        # create parameter keys conversion hash
+        pdefs = {}
+        param_defs.each_pair do |k, v|
+          k = k.to_sym
+          if v.is_a?(Array)
+            v.each { |x| pdefs[x.to_sym] = k }
+          else
+            pdefs[v.to_sym] = k
+          end
+        end
+        # process attribute -> annotations pairs or other arguments given
+        if attribute_defs.is_a?(Array)
+          attribute_defs.each { |arg| setup_attributes_set(set_name, arg, param_defs, default_param) }
+        elsif attribute_defs.is_a?(Hash)
+          output_set = {}
+          attribute_defs.each_pair do |atr_name, atr_annotations|
+            atr_name = atr_name.to_s
+            output_set[atr_name] = {}
+            if atr_annotations.is_a?(Hash)
+              atr_annotations.each_pair do |an_key, an_val|
+                an_key = an_key.to_sym
+                an_key = pdefs[an_key] if pdefs.key?(an_key)
+                output_set[atr_name][an_key] = an_val
+              end
+            elsif !default_param.nil?
+              output_set[atr_name][default_param.to_sym] = atr_annotations
+            end
+          end
+          attribute_set(set_name, output_set)
+        else
+          attribute_set(set_name, *attribute_defs)
+        end
+        nil
+      end
+      alias_method :setup_attributes_that, :setup_attributes_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]
+      # @return [nil]
       def delete_annotation_from_set(set_name, atr_name = nil, *annotations)
         if set_name.is_a?(Hash)
           r = {}
@@ -99,32 +160,34 @@ module ActiveModel
           end
         else
           set_name = set_name.to_sym
-          return unless __attribute_sets.include?(set_name) && atr_name.present?
+          return nil unless __attribute_sets.key?(set_name) && atr_name.present?
           atr_name = atr_name.to_sym
           __attribute_sets[set_name].delete_annotation(atr_name, *annotations)
         end
+        nil
       end
       alias_method :delete_annotations_from_set,  :delete_annotation_from_set
-      alias_method :unannotate_set,               :delete_annotation_from_set
+      alias_method :deletes_annotation_from_set,  :delete_annotation_from_set
+      alias_method :deletes_annotations_from_set, :delete_annotation_from_set
     end # module ClassMethods
   end # module AttributeFilters
 
-  module AttributeSet::Annotations
+  class AttributeSet
     # 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]
+    # @return [nil]
     def annotate(atr_name, name, value)
       atr_name = atr_name.to_s unless atr_name.blank?
-      unless include?(atr_name)
+      unless key?(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
+      self[atr_name] = Hash.new unless self[atr_name].is_a?(Hash)
+      self[atr_name][name.to_sym] = value
+      nil
     end
     alias_method :add_op,   :annotate
     alias_method :bind_op,  :annotate
@@ -147,11 +210,11 @@ module ActiveModel
     #   @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 false if empty?
       return true if args.size == 0
       atr_name = args.shift.to_s
-      a_group = annotations[atr_name]
-      a_group.blank? and return false
+      a_group = self[atr_name]
+      return false if a_group.blank? || !a_group.is_a?(Hash)
       args.empty? and return true
       args.any? { |a_name| a_group.key?(a_name.to_sym) }
     end
@@ -168,23 +231,17 @@ module ActiveModel
     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?
+      an_group = self[atr_name.to_s]
+      return nil if an_group.nil? || !an_group.is_a?(Hash)
       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
+        an_group.each_pair { |k, v| r[k] = AFHelpers.safe_dup(v) }
         r
       when 1
-        r = an_group[annotation_names.first.to_sym]
-        r.is_a?(Enumerable) ? r.dup : r
+        AFHelpers.safe_dup(an_group[annotation_names.first.to_sym])
       else
-        annotation_names.map do |a|
-          r = an_group[a.to_sym]
-          r.is_a?(Enumerable) ? r.dup : r
-        end
+        annotation_names.map { |a| AFHelpers.safe_dup(an_group[a.to_sym]) }
       end
     end
     alias_method :get_annotation,   :annotation
@@ -199,61 +256,37 @@ module ActiveModel
     # @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?
+      return nil if 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)
+      return nil unless key?(atr_name)
+      ag = self[atr_name]
+      return nil if ag === true
+      if annotation.nil? || !ag.is_a?(Hash)
+        self[atr_name] = true
+        return ag
       else
-        nil
+        r = ag.delete(annotation.to_sym)
+        self[atr_name] = true if ag.empty?
+        r
       end
     end
     alias_method :delete_annotations, :delete_annotation
 
     # Removes all annotations.
-    # @return [void]
+    # @return [nil]
     def remove_annotations
-      @annotations = nil
+      each_pair { |k, v| self[k] = true }
+      nil
     end
 
-    private
-
+    # Returns all annotations that are set.
+    # 
+    # @return [Hash{String => Hash}] annotations indexed by attribute names
     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
+      Hash.new.tap do |r|
+        each_pair { |atr_name, an| r[atr_name] = an.deep_dup if an.is_a?(Hash) }
       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 # class AttributeSet
 end # module ActiveModel