attribute-filters 1.4.0 → 2.0.0

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

@@ -21,21 +21,25 @@ module ActiveModel
         # +should_be_stripped+. It operates directly on attribute's contents.
         # 
         # @note If a value of currently processed attribute is an array
-        #  then any element of the array is changed.
+        #  then any element of the array is changed. The same with hash (its values are changed).
         # 
         # @return [void]
         def strip_attributes
           filter_attrs_from_set(:should_be_stripped) do |atr|
-            AttributeFiltersHelpers.each_element(atr, String) { |v| v.strip }
+            AFHelpers.each_element(atr, String) { |v| v.strip }
           end
         end
+        filtering_method :strip_attributes, :should_be_stripped
+
         # This submodule contains class methods used to easily define filter.
         module ClassMethods
           # Registers attributes that should be stripped.
           def strip_attributes(*args)
             attributes_that(:should_be_stripped, args)
           end
-          alias_method :strip_attribute, :strip_attributes
+          alias_method :strip_attribute,    :strip_attributes
+          alias_method :strips_attribute,   :strip_attributes
+          alias_method :strips_attributes,  :strip_attributes
         end # module ClassMethods
       end # module Strip
 

data/lib/attribute-filters/dsl_attr_virtual.rb

@@ -25,7 +25,7 @@ module ActiveModel
             writer_name = "#{atr_name}="
             atr_name = atr_name.to_sym
             attr_reader(atr_name) unless method_defined?(atr_name)
-            attr_accessible(atr_name) if method_defined?(:attr_accessible)
+            treat_as_virtual(atr_name)
             if method_defined?(writer_name)
               self.class_eval <<-EVAL
                 alias_method :#{atr_name}_without_change_tracking=, :#{writer_name}
@@ -43,6 +43,7 @@ module ActiveModel
               EVAL
             end
           end
+          nil
         end # def attr_virtual
       end # unless method_defined?(:attr_virtual)
     end # module ClassMethods

data/lib/attribute-filters/dsl_filters.rb

@@ -17,6 +17,9 @@ module ActiveModel
       :include_missing    => false
     }.freeze
 
+    # Helpers module shortcut.
+    AFHelpers = AttributeFiltersHelpers
+
     # Gets names of attributes for which filters should be applied by
     # selecting attributes that are meeting certain criteria and belong
     # to the given attribute set.
@@ -24,28 +27,26 @@ module ActiveModel
     # @overload attributes_to_filter(set_name, process_all, no_presence_check)
     #   @param set_name [String,Symbol] name of a set of attributes used to get attributes
     #   @param process_all [Boolean] if set then all the attributes from the attribute set are selected,
-    #     not just attributes that have changed (defaults to +false+)
-    #   @param no_presence_check [Boolean] if set then the checking whether attribute exists will be
+    #     not just the attributes that have changed (defaults to +false+)
+    #   @param no_presence_check [Boolean] if set then the checking whether each attribute exists will be
     #     disabled (matters only when +process_all+ is also set) (defaults to +false+)
     #   @return [AttributeSet] set of attributes (attribute name => previous_value)
     # 
     # @overload attributes_to_filter(attribute_set, process_all, no_presence_check)
     #   @param attribute_set [AttributeSet] set of attributes used to get attributes
     #   @param process_all [Boolean] if set then all the attributes from the attribute set are selected,
-    #     not just attributes that has changed (defaults to +false+)
-    #   @param no_presence_check [Boolean] if set then the checking whether attribute exists will be
+    #     not just the attributes that has changed (defaults to +false+)
+    #   @param no_presence_check [Boolean] if set then the checking whether each attribute exists will be
     #     disabled (matters only when +process_all+ is also set) (defaults to +false+)
     #   @return [AttributeSet] set of attributes (attribute name => previous_value)
     def attributes_to_filter(set_name, process_all = false, no_presence_check = false)
-      atf = set_name.is_a?(::ActiveModel::AttributeSet) ? set_name : attribute_set_simple(set_name)
+      set_name.blank? and return ::ActiveModel::AttributeSet.new
+      atf = set_name.is_a?(::ActiveModel::AttributeSet) ? set_name : self.class.send(:__attribute_sets)[set_name.to_sym]
       if process_all
-        no_presence_check ? atf : atf & all_attributes_simple(no_presence_check)
+        no_presence_check ? atf.deep_dup : atf & __all_attributes(false)
       else
-        if self.class.filter_virtual_attributes_that_changed?
-          atf & changes.keys
-        else
-          atf & (__vatrf(no_presence_check)  + changes.keys)
-        end
+        sr = self.class.send(:__attribute_filters_semi_real)
+        atf & ((no_presence_check ? sr : sr.select_accessible(self)) + changes.keys)
       end
     end
 
@@ -141,7 +142,7 @@ module ActiveModel
     #     * +:no_presence_check+ – tells not to check for existence of each processed attribute when processing
     #       all attributes; increases performance but you must care about putting into set only the existing attributes
     #     * +:include_missing+ – includes attributes that does not exist in a resulting iteration (their values are
-    #       always +nil+); has effect only when +process_blank+ and +no_presence_check+ are set to +true+
+    #       always +nil+); has the effect only when +process_blank+ and +no_presence_check+ are set
     #   @yield [attribute_value, set_name, attribute_name, *args] block that will be called for each attribute
     #   @yieldparam attribute_value [Object] current attribute value that should be altered
     #   @yieldparam attribute_name [String] a name of currently processed attribute
@@ -174,60 +175,12 @@ 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
-      alias_method :virtual_attributes_are_tracked,         :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)
       block_given? or return enum_for(__method__, set_name, alter_mode, *args)
-      flags             = AttributeFiltersHelpers.process_flags(args)
+      flags             = AFHelpers.process_flags(args)
       process_all       = flags[:process_all]
       process_blank     = flags[:process_blank]
       no_presence_check = flags[:no_presence_check]

data/lib/attribute-filters/dsl_sets.rb

@@ -29,6 +29,9 @@ module ActiveModel
     # If the argument is a kind of {AttributeSet} then the local set
     # is taken and wrapped in a {AttributeSet::AttrQuery} instance.
     # 
+    # If the argument is +nil+ then the local set is guessed by assuming
+    # that the next method in a call chain is really the name of a set.
+    #
     # If the argument is other kind than the specified above then
     # the method tries to initialize new, local set object and wraps
     # it in a `AttributeSet::AttrQuery` instance.
@@ -40,23 +43,20 @@ module ActiveModel
     # 
     # @param set_name [Symbol] name of attribute set, attribute object or any object that can initialize a set
     # @return [AttributeSet] attribute set
-    def attribute_set(set_name=nil)
-      if set_name.nil?
-        all_attributes
-      else
-        ActiveModel::AttributeSet::Query.new(set_name, self)
-      end
+    def attribute_set(set_name = nil)
+      ActiveModel::AttributeSet::Query.new(set_name, self)
     end
     alias_method :attributes_that_are,        :attribute_set
     alias_method :from_attributes_that,       :attribute_set
+    alias_method :are_attributes_that,        :attribute_set
     alias_method :are_attributes_that_are,    :attribute_set
+    alias_method :are_attributes,             :attribute_set
+    alias_method :are_attributes_for,         :attribute_set
     alias_method :from_attributes_that_are,   :attribute_set
-    alias_method :within_attributes_that_are, :attribute_set
+    alias_method :in_attributes_that_are,     :attribute_set
     alias_method :attributes_that,            :attribute_set
     alias_method :attributes_are,             :attribute_set
     alias_method :attributes_for,             :attribute_set
-    alias_method :are_attributes,             :attribute_set
-    alias_method :are_attributes_for,         :attribute_set
     alias_method :attributes_set,             :attribute_set
     alias_method :properties_that,            :attribute_set
 
@@ -71,25 +71,21 @@ module ActiveModel
     # @param set_name [Symbol] name of attribute set
     # @return [AttributeSet] attribute set
     def attribute_set_simple(set_name)
-      self.class.attribute_set(set_name).dup
+      self.class.attribute_set(set_name)
     end
 
     # Returns a set containing all known attributes
-    # without wrapping it in a proxy.
-    # 
-    # @return [AttributeSet] attribute set
-    def all_attributes_simple(no_presence_check = true)
-      (ActiveModel::AttributeSet.new(attributes.keys) +
-      all_accessible_attributes(true) +
-      all_protected_attributes(true)  +
-      __vatrf(no_presence_check)).delete("")
-    end
-
-    # Returns a set containing all known attributes.
+    # without wrapping the result in a proxy.
     # 
+    # @param simple [Boolean] optional parameter that disables
+    #   wrapping a resulting set in a proxy (defaults to +false+)
+    # @param no_presence_check [Boolean] optional parameter that
+    #  disables checking for presence of setters and getters for each
+    #  virtual and semi-real attribute (defaults to +true+)
     # @return [AttributeSet] attribute set
-    def all_attributes
-      ActiveModel::AttributeSet::Query.new(all_attributes_simple, self)
+    def all_attributes(simple = false, no_presence_check = true)
+      r = __all_attributes(no_presence_check).deep_dup
+      simple ? r : ActiveModel::AttributeSet::Query.new(r, self)
     end
     alias_method :all_attributes_set, :all_attributes
 
@@ -99,8 +95,9 @@ module ActiveModel
     #   wrapping a resulting set in a proxy (defaults to +false+)
     # @return [AttributeSet] attribute set
     def all_accessible_attributes(simple = false)
-      c = self.class.class_eval { respond_to?(:accessible_attributes) ? accessible_attributes : [] }
-      simple ? AttributeSet.new(c) : AttributeSet::Query.new(c)
+      my_class = self.class
+      c = my_class.respond_to?(:accessible_attributes) ? my_class.accessible_attributes : []
+      simple ? AttributeSet.new(c) : AttributeSet::Query.new(c, self)
     end
     alias_method :accessible_attributes_set, :all_accessible_attributes
 
@@ -110,15 +107,50 @@ module ActiveModel
     #   wrapping a resulting set in a proxy (defaults to +false+)
     # @return [AttributeSet] attribute set
     def all_protected_attributes(simple = false)
-      c = self.class.class_eval { respond_to?(:protected_attributes) ? protected_attributes : [] }
-      simple ? AttributeSet.new(c) : AttributeSet::Query.new(c)
+      my_class = self.class
+      c = my_class.respond_to?(:protected_attributes) ? my_class.protected_attributes : []
+      simple ? AttributeSet.new(c) : AttributeSet::Query.new(c, self)
     end
     alias_method :protected_attributes_set, :all_protected_attributes
 
+    # Returns a set containing attributes declared as virtual with +attr_virtual+.
+    # 
+    # @param simple [Boolean] optional parameter that disables
+    #   wrapping a resulting set in a proxy (defaults to +false+)
+    # @return [AttributeSet] attribute set
+    def all_virtual_attributes(simple = false)
+      c = self.class.attribute_filters_virtual
+      simple ? c : AttributeSet::Query.new(c, self)
+    end
+    alias_method :virtual_attributes_set, :all_virtual_attributes
+    alias_method :attribute_filters_virtual, :all_virtual_attributes
+
+    # Returns a set containing attributes declared as semi-real.
+    # 
+    # @param simple [Boolean] optional parameter that disables
+    #   wrapping a resulting set in a proxy (defaults to +false+)
+    # @param no_presence_check [Boolean] optional parameter that
+    #  disables checking for presence of setters and getters for each
+    #  attribute (defaults to +true+)
+    # @return [AttributeSet] attribute set
+    def all_semi_real_attributes(simple = false, no_presence_check = true)
+      c = self.class.treat_as_real
+      c = c.select_accessible(self) unless no_presence_check || c.empty? 
+      simple ? c : AttributeSet::Query.new(c, self)
+    end
+    alias_method :semi_real_attributes_set, :all_semi_real_attributes
+    alias_method :treat_as_real, :all_semi_real_attributes
+
     # Returns a set containing all attributes that are not accessible attributes.
+    # 
+    # @param simple [Boolean] optional parameter that disables
+    #   wrapping a resulting set in a proxy (defaults to +false+)
+    # @param no_presence_check [Boolean] optional parameter that
+    #  disables checking for presence of setters and getters for each
+    #  virtual and semi-real attribute (defaults to +true+)
     # @return [AttributeSet] attribute set
-    def all_inaccessible_attributes
-      all_attributes - all_accessible_attributes(true)
+    def all_inaccessible_attributes(simple = false, no_presence_check = true)
+      all_attributes(simple, no_presence_check) - all_accessible_attributes(simple)
     end
     alias_method :all_non_accessible_attributes,  :all_inaccessible_attributes
     alias_method :inaccessible_attributes_set,    :all_inaccessible_attributes
@@ -129,21 +161,31 @@ module ActiveModel
     #  will always return {AttributeSet} object. If there is no such set defined then the returned,
     #  matching set will be empty.
     # 
-    # @return [Hash{Symbol => AttributeSet<String>}] the collection of attribute sets indexed by their names
+    # @return [MetaSet{Symbol => AttributeSet<String>}] the collection of attribute sets indexed by their names
     def attribute_sets
       s = self.class.attribute_sets
-      s.merge!(s) do |set_name, set_object|
-        ActiveModel::AttributeSet::Query.new(set_object, self)
+      s.each_pair do |set_name, set_object|
+        s[set_name] = ActiveModel::AttributeSet::Query.new(set_object, self)
       end
-      s.default = ActiveModel::AttributeSet::Query.new(ActiveModel::AttributeSet.new.freeze, self)
       s
     end
     alias_method :attributes_sets, :attribute_sets
     alias_method :properties_sets, :attribute_sets
 
+    # Checks if the given set exists.
+    # 
+    # @param [String, Symbol] set_name name of a set
+    # @return [Boolean] +true+ if a set of the given name exists, +false+ otherwise
+    def attribute_set_exists?(set_name)
+      set_name.present? && self.class.send(:__attribute_sets).key?(set_name.to_sym)
+    end
+
     # Returns the set of set names that the attribute of the given
     # name belongs to.
     # 
+    # If the given attribute name is +nil+ then it is taken from
+    # the name of a next method in a method call chain.
+    # 
     # @note The returned value is a duplicate. Adding or removing
     #  elements to it will have no effect. Altering attribute sets
     #  is possible on a class-level only, since attribute sets
@@ -151,26 +193,64 @@ module ActiveModel
     # 
     # @param attribute_name [Symbol] name of attribute set
     # @return [AttributeSet] attribute set
-    def filtered_attribute(attribute_name)
-      ActiveModel::AttributeSet::AttrQuery.new(self.class.filter_attribute(attribute_name), self, attribute_name)
+    def filtered_attribute(attribute_name = nil)
+      ActiveModel::AttributeSet::AttrQuery.new(attribute_name, self)
     end
     alias_method :the_attribute,        :filtered_attribute
     alias_method :is_the_attribute,     :filtered_attribute
+    alias_method :has_the_attribute,    :filtered_attribute
     alias_method :are_attributes,       :filtered_attribute
     alias_method :are_the_attributes,   :filtered_attribute
 
+    # Returns the set of set names that the attribute of the given
+    # name belongs to.
+    # 
+    # @note The returned value is a duplicate. Adding or removing
+    #  elements to it will have no effect. Altering attribute sets
+    #  is possible on a class-level only, since attribute sets
+    #  are part of models' interfaces.
+    # 
+    # @param attribute_name [Symbol] name of attribute set
+    # @return [AttributeSet] attribute set
+    def filtered_attribute_simple(attribute_name)
+      self.class.filter_attribute(attribute_name)
+    end
+    alias_method :the_attribute_simple, :filtered_attribute_simple
+
     # Gets all the defined attribute set names hashed by attribute names.
     # 
     # @note Use +key+ method explicitly to check if the given attribute is assigned to any set. The hash
     #  returned by this method will always return {AttributeSet} object. If the attribute is not assigned
     #  to any set then the returned, matching set will be empty.
     # 
-    # @return [Hash{String => AttributeSet<Symbol>}] the collection of attribute set names indexed by attribute names
+    # @return [MetaSet{String => AttributeSet<Symbol>}] the collection of attribute set names indexed by attribute names
     def attributes_to_sets
       self.class.attributes_to_sets
     end
     alias_method :attribute_sets_map, :attributes_to_sets
 
+    # Returns a set containing all known attributes
+    # without wrapping the result in a proxy.
+    # 
+    # @param no_presence_check [Boolean] optional parameter that
+    #  disables checking for presence of setters and getters for each
+    #  virtual and semi-real attribute (defaults to +true+)
+    # @return [AttributeSet] attribute set
+    def __all_attributes(no_presence_check = true)
+      my_class = self.class
+      c = my_class.send(:__attribute_filters_semi_real)
+      c = c.select_accessible(self) unless no_presence_check || c.empty?
+      r = ActiveModel::AttributeSet.new(c)
+      r.merge!(my_class.send(:__attribute_filters_virtual))
+      r << attributes.keys
+      if respond_to?(:accessible_attributes)
+        r << accessible_attributes
+        r << protected_attributes
+      end
+      r
+    end
+    private :__all_attributes
+
     # This module contains class methods
     # that create DSL for managing attribute sets.
     module ClassMethods
@@ -207,31 +287,38 @@ module ActiveModel
           attribute_sets
         when 1
           first_arg = args.first
-          if first_arg.is_a?(Hash) # multiple sets defined
+          if first_arg.is_a?(Hash)                              # [write] multiple sets defined
             first_arg.each_pair { |k, v| attribute_set(k, v) }
             nil
-          else
-            attribute_sets[first_arg.to_sym]
+          else                                                  # [read] single set to read
+            r = __attribute_sets[first_arg.to_sym]
+            r.frozen? ? r : r.deep_dup
           end
         else
           first_arg = args.shift
-          if first_arg.is_a?(Hash) # multiple sets defined
+          if first_arg.is_a?(Hash)                              # [write] multiple sets defined
             first_arg.each_pair do |k, v|
               attribute_set(k, v, args)
             end
-          else
-            AttributeFiltersHelpers.check_wanted_methods(self)
+          else                                                  # [write core] sinle set and optional attrs given
+            AFHelpers.check_wanted_methods(self)
             add_atrs_to_set(first_arg.to_sym, *args)
           end
           nil
         end
       end
-      alias_method :attributes_that_are,  :attribute_set
-      alias_method :attributes_that,      :attribute_set
-      alias_method :attributes_are,       :attribute_set
-      alias_method :attributes_for,       :attribute_set
-      alias_method :attributes_set,       :attribute_set
-      alias_method :properties_that,      :attribute_set
+      alias_method :attributes_set,           :attribute_set
+      alias_method :attributes_that_are,      :attribute_set
+      alias_method :attributes_that,          :attribute_set
+      alias_method :properties_that,          :attribute_set
+      alias_method :has_attribute_set,        :attribute_set
+      alias_method :has_attribute_that,       :attribute_set
+      alias_method :has_attribute_that_is,    :attribute_set
+      alias_method :has_attributes,           :attribute_set
+      alias_method :has_attributes_set,       :attribute_set
+      alias_method :has_attributes_that_are,  :attribute_set
+      alias_method :has_attributes_that,      :attribute_set
+      alias_method :has_properties_that,      :attribute_set
 
       # @overload filter_attribute()
       #   Gets all the defined attribute sets.
@@ -262,7 +349,7 @@ module ActiveModel
       #   @param set_names [Array<Symbol,String>] names of additional sets to assign attributes to
       #   @return [nil]
       def filter_attribute(*args)
-        AttributeFiltersHelpers.check_wanted_methods(self)
+        AFHelpers.check_wanted_methods(self)
         case args.size
         when 0
           attributes_to_sets
@@ -272,7 +359,8 @@ module ActiveModel
             first_arg.each_pair { |k, v| filter_attribute(k, v) }
             nil
           else
-            attributes_to_sets[first_arg.to_s]
+            r = __attributes_to_sets_map[first_arg.to_s]
+            r.frozen? ? r : r.deep_dup
           end
         else
           first_arg = args.shift
@@ -295,12 +383,17 @@ module ActiveModel
           nil
         end
       end
-      alias_method :the_attribute,        :filter_attribute
-      alias_method :add_attribute_to_set, :filter_attribute
-      alias_method :add_attribute_to_sets,:filter_attribute
-      alias_method :attribute_to_set,     :filter_attribute
-      alias_method :filtered_attribute,   :filter_attribute
-      alias_method :filtered_attributes,  :filter_attribute
+      alias_method :the_attribute,            :filter_attribute
+      alias_method :attribute_to_set,         :filter_attribute
+      alias_method :filtered_attribute,       :filter_attribute
+      alias_method :filtered_attributes,      :filter_attribute
+      alias_method :filters_attribute,        :filter_attribute
+      alias_method :filters_attributes,       :filter_attribute
+      alias_method :its_attribute,            :filter_attribute
+      alias_method :has_attribute,            :filter_attribute
+      alias_method :has_the_attribute,        :filter_attribute
+      alias_method :has_filtered_attribute,   :filter_attribute
+      alias_method :has_filtered_attributes,  :filter_attribute
 
       # Gets all the defined attribute sets.
       # 
@@ -308,13 +401,9 @@ module ActiveModel
       #  will always return {AttributeSet} object. If there is no such set defined then the returned,
       #  matching set will be empty. All set objects are duplicates of the defined sets.
       # 
-      # @return [Hash{Symbol => AttributeSet<String>}] the collection of attribute sets indexed by their names
+      # @return [MetaSet{Symbol => AttributeSet<String>}] the collection of attribute sets indexed by their names
       def attribute_sets
-        d = Hash.new(ActiveModel::AttributeSet.new.freeze)
-        __attribute_sets.each_pair do |set_name, set_object|
-          d[set_name] = set_object.dup
-        end
-        d
+        __attribute_sets.deep_dup
       end
       alias_method :attributes_sets, :attribute_sets
       alias_method :properties_sets, :attribute_sets
@@ -323,26 +412,87 @@ module ActiveModel
       # 
       # @note Use +key+ method explicitly to check if the given attribute is assigned to any set. The hash
       #  returned by this method will always return {AttributeSet} object. If the attribute is not assigned
-      #  to any set then the returned, matching set will be empty.
+      #  to any set then the returned, matching set will be empty. This method returns a duplicate of each
+      #  reverse mapped set.
       # 
-      # @return [Hash{String => AttributeSet<Symbol>}] the collection of attribute set names indexed by attribute names
+      # @return [MetaSet{String => AttributeSet<Symbol>}] the collection of attribute set names indexed by attribute names
       def attributes_to_sets
-        d = Hash.new(ActiveModel::AttributeSet.new.freeze)
-        __attributes_to_sets_map.each_pair do |set_name, set_object|
-          d[set_name] = set_object.dup
-        end
-        d
+        __attributes_to_sets_map.deep_dup
       end
       alias_method :attribute_sets_map, :attributes_to_sets
 
+      # @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 semi-virtual attributes.
+      # 
+      #   @note To operate on virtual attributes use +attr_virtual+ instead.
+      #   
+      #   @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 names
+      def treat_as_real(*args)
+        return __attribute_filters_semi_real.deep_dup if args.blank?
+        __attribute_filters_semi_real << args.flatten.compact.map { |atr| atr.to_s }
+        nil
+      end
+      alias_method :attribute_filters_semi_real,  :treat_as_real
+      alias_method :treat_attribute_as_real,      :treat_as_real
+      alias_method :treat_attributes_as_real,     :treat_as_real
+      alias_method :treats_attribute_as_real,     :treat_as_real
+      alias_method :treats_attributes_as_real,    :treat_as_real
+      alias_method :treats_as_real,               :treat_as_real
+
+      # @overload attribute_filters_virtual(*attributes)
+      #   Informs Attribute Filters that the given attributes
+      #   should be treated as virtual (even not present in the
+      #   attributes hash provided by ORM or ActiveModel).
+      #   
+      #   @note This method may be used directly if your setter
+      #    notifies Rails about changes. Otherwise it's recommended
+      #    to use the DSL keyword +attr_virtual+.
+      #   @param attributes [Array] list of attribute names
+      #   @return [void]
+      # 
+      # @overload attribute_filters_virtual()
+      #   Gets the memorized attribute names that should be
+      #   treated as virtual.
+      #   
+      #   @return [AttributeSet] set of attribute names
+      def treat_as_virtual(*args)
+        return __attribute_filters_virtual.deep_dup if args.blank?
+        __attribute_filters_virtual << args.flatten.compact.map { |atr| atr.to_s }
+        nil
+      end
+      alias_method :attribute_filters_virtual,    :treat_as_virtual
+      alias_method :treat_attribute_as_virtual,   :treat_as_virtual
+      alias_method :treat_attributes_as_virtual,  :treat_as_virtual
+      alias_method :treats_attribute_as_virtual,  :treat_as_virtual
+      alias_method :treats_attributes_as_virtual, :treat_as_virtual
+      alias_method :treats_as_virtual,            :treat_as_virtual
+
       private
 
+      def __attribute_filters_semi_real
+        @__attribute_filters_semi_real ||= ActiveModel::AttributeSet.new
+      end
+
+      def __attribute_filters_virtual
+        @__attribute_filters_virtual ||= ActiveModel::AttributeSet.new
+      end
+
       def __attributes_to_sets_map
-        @__attributes_to_sets_map ||= Hash.new
+        @__attributes_to_sets_map ||= MetaSet.new(ActiveModel::MetaSet.new.freeze)
       end
 
       def __attribute_sets
-        @__attribute_sets ||= Hash.new
+        @__attribute_sets ||= MetaSet.new(ActiveModel::AttributeSet.new.freeze)
       end
 
       def add_atrs_to_set(set_name, *atrs)
@@ -351,29 +501,29 @@ module ActiveModel
           if atr_name.is_a?(Hash) # annotation
             atr_name.each_pair do |atr_name_b, a_defs|
               add_atrs_to_set(set_name, atr_name_b)
-              s = __attribute_sets[set_name] and a_defs.nil? or a_defs.each_pair { |n, v| s.annotate(atr_name_b, n, v) }
+              if __attribute_sets.key?(set_name) && a_defs.is_a?(Hash)
+                a_defs.each_pair do |n, v|
+                  __attribute_sets[set_name].annotate(atr_name_b, n, v)
+                end
+              end
             end
-            return
+            return nil
           else
             atr_name = atr_name.to_s
-            __attributes_to_sets_map[atr_name] ||= ActiveModel::AttributeSet.new
-            __attributes_to_sets_map[atr_name] << set_name
+            unless __attributes_to_sets_map.key?(atr_name)
+              __attributes_to_sets_map[atr_name] = ActiveModel::MetaSet.new
+            end
+              __attributes_to_sets_map[atr_name] << set_name
           end
         end
-        __attribute_sets[set_name] ||= ActiveModel::AttributeSet.new
-        __attribute_sets[set_name] << atrs.map{ |a| a.to_s }.freeze
+        sanitized_atrs = atrs.map{ |a| a.to_s.dup }
+        unless __attribute_sets.key?(set_name)
+          __attribute_sets[set_name] = ActiveModel::AttributeSet.new(sanitized_atrs)
+        else
+          __attribute_sets[set_name] << sanitized_atrs
+        end
+        nil
       end
     end # module ClassMethods
-
-    private
-
-    # Helper that collects untracked 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 AttributeMethods
 end # module ActiveModel