attribute-filters 2.0.0 → 2.0.1

data/ChangeLog

@@ -1,3 +1,54 @@
+commit 364a5df0dfe8bed367351c55b7b64c174b2a3d91
+Author: Paweł Wilk <siefca@gnu.org>
+Date:   Sun Nov 4 16:44:10 2012 +0100
+
+    Version 2.0.1
+
+commit ae4f36ca7f011045898f0d21a2a7c4fad3064446
+Author: Paweł Wilk <siefca@gnu.org>
+Date:   Sun Nov 4 16:17:03 2012 +0100
+
+    Tracking changes of virtual attributes improved; wrapping method is now waiting for a getter method
+
+commit de71213689e9246e8694f65fc26b4dfb84e9e940
+Author: Paweł Wilk <siefca@gnu.org>
+Date:   Sun Nov 4 16:16:10 2012 +0100
+
+    Added AttributeSet#to_hash and AttributeSet#to_attribute_set
+
+commit 732f6a0546bd2420f676d52dcc6be54fc190ea61
+Author: Paweł Wilk <siefca@gnu.org>
+Date:   Sun Nov 4 03:26:57 2012 +0100
+
+    Virtual attributes tracking improved; now the placement of attr_virtual keyword does not matter
+
+commit d7c3b087fd0cdb66ad7a42e30ae55d2d896ff505
+Author: Paweł Wilk <siefca@gnu.org>
+Date:   Sun Nov 4 03:25:42 2012 +0100
+
+    Created abstraction layer that allows to keep all needed data in two class instance variables:
+    
+    - @attribute_sets (for sets, attributes map, virtual and semi-real items),
+    - @attribute_filters (for filtering methods).
+
+commit f1e63bc24ceb941e84e354f3f28ead899eaacc77
+Author: Paweł Wilk <siefca@gnu.org>
+Date:   Fri Nov 2 08:43:48 2012 +0100
+
+    MetaSet improved, removed grandparent.class.bind(self).call
+
+commit b5a915f50d823d39657a91b1513e0ba4bd690490
+Author: Paweł Wilk <siefca@gnu.org>
+Date:   Thu Nov 1 20:57:25 2012 +0100
+
+    Description updated
+
+commit bda2e1073095712fe1aece55dbf40ac5fb4f4bc9
+Author: Paweł Wilk <siefca@gnu.org>
+Date:   Thu Nov 1 20:48:24 2012 +0100
+
+    Gem description updated
+
 commit 9d5082a0f3d5b9349b1792a420f273b9898f1a9e
 Author: Paweł Wilk <siefca@gnu.org>
 Date:   Thu Nov 1 17:07:24 2012 +0100

data/README.md

@@ -16,6 +16,11 @@ and some syntactic sugar to Rails, thereby allowing you
 to express filtering and grouping model attributes
 in a concise and clean way.
 
+If you are a fan of declarative style, this gem is for you.
+It lets you program your models in a way that it's clear
+to see what's going on with attributes just by looking
+at the top of their classes.
+
 When?
 -----
 
@@ -152,6 +157,20 @@ class User < ActiveRecord::Base
 end
 ```
 
+Tracking changes and filtering virtual attributes is also easy:
+
+```ruby
+class User < ActiveRecord::Base
+  include ActiveModel::AttributeFilters::Split
+  
+  split_attribute   :real_name => [ :first_name, :last_name ]
+  before_validation :filter_attributes
+  
+  attr_virtual  :real_name
+  attr_accessor :real_name
+end
+```
+
 Usage and more examples
 -----------------------
 

data/attribute-filters.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |s|
   s.name = "attribute-filters"
-  s.version = "2.0.0.20121101164113"
+  s.version = "2.0.1.20121104164328"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Pawe\u{142} Wilk"]
   s.cert_chain = ["/Users/siefca/.gem/gem-public_cert.pem"]
-  s.date = "2012-11-01"
+  s.date = "2012-11-04"
   s.description = "Concise way of filtering model attributes in Rails."
   s.email = ["pw@gnu.org"]
   s.extra_rdoc_files = ["Manifest.txt"]
@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.rubyforge_project = "attribute-filters"
   s.rubygems_version = "1.8.24"
   s.signing_key = "/Users/siefca/.gem/gem-private_key.pem"
-  s.summary = "Concise way of filtering model attributes in Rails"
+  s.summary = "Concise way of filtering and grouping model attributes in Rails"
 
   if s.respond_to? :specification_version then
     s.specification_version = 3

data/docs/HISTORY

@@ -1,11 +1,25 @@
+=== 2.0.1 / 2012-10-04
+
+* major enhancements
+
+  * Virtual attributes changes tracking improved; the `attr_virtual` DSL keyword can be placed anywhere
+  * Internal sets refactored, added abstraction layer that utilizes just two class instance variables:
+    * `@attribute_sets` (for keeping sets, attributes map, virtual and semi-real items)
+    * `@attribute_filters` (for keeping filtering methods)
+
+* minor enhancements
+
+  * Added conversion methods: AttributeSet#to_hash, AttributeSet#to_attribute_set
+  * `MetaSet` improved, removed grandparent.class.bind(self).call
+
 === 2.0.0 / 2012-10-01
 
 * major enhancements
 
   * Operating speed increased by 100%
   * API change:
-    * AttributeSet is now based on a Hash
-    * Added MetaSet for keeping sets of attribute sets
+    * `AttributeSet` is now based on a Hash
+    * Added `MetaSet` for keeping sets of attribute sets
     * Added DSL keyword for registering filtering methods
     * DSL method `filter_attributes` is using filtering methods registered before
   * Creation of duplicates for sets moved to class-level accessors

data/docs/TODO

@@ -1,9 +1,3 @@
-
-* attr_virtual - wrap method_defined? and add some gotchas into it that will wait for accessor to be added
-  there already is a hash for attr_virtual, all we need to do is to check any added accessor against that hash
-  that will only apply when there weren't accessors while using attr_virtual
-
-
 * add sanitize to common filters
   -- sanitize_url
   -- sanitize_string

data/docs/USAGE.md

@@ -508,6 +508,45 @@ Example:
   # =>  #<ActiveModel::AttributeSet: {"lol"}> 
 ```
 
+You can check which virtual attribute is automatically tracked for changes (was added using `attr_virtual`
+and has wrapped setter method), which is still waiting for its setter and getter methods to be created,
+and which was added using `treat_as_virtual` with the assumption that the changes tracking will be done
+manually by the properly constructed setter.
+
+Each element of a set containing virtual attributes has a control marker attached to it (instead of annotations) so
+you can read this marker to know what is the status of a certain attribute.
+
+To get a hash of attributes and statuses pairs you may use (in an instance method that belongs to a model):
+
+```ruby
+  all_virtual_attributes.to_hash
+```
+
+or just print them:
+
+```ruby
+  all_virtual_attributes.each_pair{ |k,v| puts "#{k}: #{v}" }
+```
+
+To read the status of a single attribute:
+
+```ruby
+  all_virtual_attributes["attribute_name"]
+```
+
+To select the attributes that are meeting certain criteria:
+
+```ruby
+  all_virtual_attributes.select{|k,v| v == :tracked}
+  end
+```
+
+The statuses are symbols and have the following meanings:
+
+  * `:no_wrap` – a virtual attribute was added using `treat_as_virtual` and changes tracking should be done manually
+  * `:tracked` – a setter method of an attribute was automatically wrapped to track changes
+  * `:waiting` – a virtual attribute is to be tracked when its setter method will be defined
+
 Instead of `all_virtual_attributes` you may also use the alias:
 
   * `virtual_attributes_set`
@@ -1339,8 +1378,8 @@ your setter and you're done.
 This approach can be easily used with predefined filters. The benefit of it,
 contrary to other methods, is that a filter will never be called redundantly.
 
-You should use the built-in DSL keyword **`attr_virtual`** that will create
-setter and getter for you.
+You should use the built-in DSL keyword **`attr_virtual`** that will enable changes
+tracking for your attribute.
 
 ```ruby
 class User < ActiveRecord::Base
@@ -1370,9 +1409,10 @@ end
 Note that for Rails version 3 you may need to declare attribute as accessible using `attr_accessible`
 if you want controllers to be able to update its value through assignment passed to model.
 
-You may change the setter and getter for vitrtual attribute on you own, but it should be done
-somewhere in the code **before** the `attr_virtual` clause. That will allow `attr_virtual`
-to wrap you methods and enable tracking of changes for the attribute.
+You have to create setter and getter for virtual attributes on you own.
+It may be done before or after `attr_virtual` keyword.
+
+Example:
 
 ```ruby
 class User < ActiveRecord::Base
@@ -1393,6 +1433,9 @@ class User < ActiveRecord::Base
   end
   filtering_method :split_attributes, :should_be_splitted
 
+  # inform AF that the model has a virtual attribute
+  has_virtual_attribute :real_name
+
   # own setter
   def real_name=(val)
     # do somehing specific here (or not)
@@ -1405,7 +1448,34 @@ class User < ActiveRecord::Base
     @real_name
   end
 
-  attr_virtual :real_name
+end
+```
+
+Instead of `attr_virtual` you may also use its alias:
+
+  * `has_virtual_attribute`
+
+There are (rare) cases when you may wish to treat attributes as virtual but without automagically wrapping their setter
+methods to track changes (e.g. setter is already doing it manually). In such cases **make sure that the setter and getter exist** and use low-level method called `treat_as_virtual`, for instance:
+
+```ruby
+class User < ActiveRecord::Base
+
+  splits_attributes :real_name
+  before_validation :filter_attributes
+
+  # inform AF that the model has a virtual attribute
+  # and changes tracking is already implemented
+  treats_as_virtual :real_name
+
+  # own getter
+  attr_reader :real_name
+
+  # own setter that implements changes tracking
+  def real_name=(val)
+    attribute_will_change!('real_name') if val != real_name
+    @real_name = val
+  end
 
 end
 ```

data/lib/attribute-filters/active_model_insert.rb

@@ -29,7 +29,6 @@ module ActiveModel
       if singleton_class.method_defined?(:included)
         singleton_class.send(:alias_method, :included_without_attribute_methods, :included)
         singleton_class.send(:alias_method, :included, :included_with_attribute_methods)
-        #singleton_class.send(:alias_method_chain, :included, :attribute_methods)
       end
 
     end # ActiveModel::AttributeMethods.class_eval

data/lib/attribute-filters/attribute_set.rb

@@ -7,131 +7,186 @@
 # 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 <  Hash
-    include ActiveModel::AttributeSet::Enumerable
-
-    # Helpers module shortcut
-    AFHelpers = ActiveModel::AttributeFilters::AttributeFiltersHelpers
+  module AttributeFilters
+    module AttributeSetMethods
+      include ActiveModel::AttributeSet::Enumerable
 
-    # 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
+      # Helpers module shortcut
+      AFHelpers = ActiveModel::AttributeFilters::AttributeFiltersHelpers
 
-    # Adds the given object to the set and returns self.
-    # If the object is already in the set, returns nil.
-    # If the object is an array it adds each element of the array.
-    # The array is not flattened so if it contains other arrays
-    # then they will be added as the arrays.
-    # When adding an array the returning value is also an array,
-    # which contains elements that were successfuly added to set
-    # and didn't existed there before.
-    # 
-    # @param 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
+      # Adds the given object to the set and returns self.
+      # If the object is already in the set, returns nil.
+      # If the object is an array it adds each element of the array.
+      # The array is not flattened so if it contains other arrays
+      # then they will be added as the arrays.
+      # When adding an array the returning value is also an array,
+      # which contains elements that were successfuly added to set
+      # and didn't existed there before.
+      # 
+      # @param 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
-      self
-    end
-    alias_method :<<, :add
+      alias_method :<<, :add
 
-    # @private
-    def to_a
-      keys
-    end
+      # Returns an array of attribute names.
+      # 
+      # @return [Array<String>]
+      def to_a
+        keys
+      end
 
-    # @private
-    def to_set
-      keys.to_set
-    end
+      # Returns a hash based on a set.
+      # 
+      # @return [Hash]
+      def to_hash
+        Hash.new.deep_merge(self)
+      end
+      alias_method :to_h, :to_hash
 
-    # 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.
-    # 
-    # @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])
+      # Returns self.
+      # 
+      # @return [AttributeSet]
+      def to_attribute_set
+        self
+      end
+
+      # Returns a set containing attribute names.
+      # 
+      # @return [Set<String>]
+      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.
+      # 
+      # @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
-      r
-    end
 
-    # Subtracts the given set from the current one
-    # by removing all the elements that have the same keys.
-    # 
-    # @return [AttributeSet] resulting set
-    def -(o)
-      o = self.class.new(o) unless o.is_a?(Hash)
-      reject { |k, v| o.include?(k) }
-    end
+      # Subtracts the given set from the current one
+      # by removing all the elements that have the same keys.
+      # 
+      # @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)
-      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 }
+      # 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)
+        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
-      r
-    end
-    alias_method :intersection, :&
-    alias_method :intersect, :&
+      alias_method :intersection, :&
+      alias_method :intersect, :&
 
-    # Returns a new attribute set containing elements
-    # exclusive between the set and the given enumerable object
-    # (exclusive disjuction).
-    # 
-    # @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]
+      # Returns a new attribute set containing elements
+      # exclusive between the set and the given enumerable object
+      # (exclusive disjuction).
+      # 
+      # @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
+
+      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
-        r[k] = AFHelpers.safe_dup(src)
       end
+    end # module AttributeSetMethods
+  end # module AttributeFilters
+  
+  # This class is a data structure used to store
+  # set of attributes.
+  class AttributeSet <  Hash
+    include AttributeFilters::AttributeSetMethods
+
+    # 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
 
@@ -149,52 +204,5 @@ module ActiveModel
       end
     end
 
-    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
-
-  # 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 # module ActiveModel

data/lib/attribute-filters/common_filters.rb

@@ -22,7 +22,7 @@ module ActiveModel
       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 = (@attribute_filters ||= MetaSet.new)
         f[set_name] = method_name unless f.key?(set_name)
         nil
       end
@@ -40,8 +40,8 @@ module ActiveModel
         def included(base)
 
           # merge filtering sets from filtering modules to models
-          fs = @__filtering_sets
-          base.class_eval { (@__filtering_sets ||= MetaSet.new).merge!(fs) } unless fs.nil?
+          fs = @attribute_filters
+          base.class_eval { (@attribute_filters ||= MetaSet.new).merge!(fs) } unless fs.nil?
 
           if  base.const_defined?(:ClassMethods)  &&
               base.instance_of?(::Module)         &&
@@ -52,8 +52,8 @@ module ActiveModel
             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?
+                  fs = @attribute_filters
+                  base.class_eval { (@attribute_filters ||= MetaSet.new).merge!(fs) } unless fs.nil?
                   base.extend ClassMethods
                 end
               end
@@ -97,7 +97,7 @@ module ActiveModel
     # 
     # @return [nil]
     def filter_attributes
-      as, fs = *self.class.class_eval { [__attribute_sets, @__filtering_sets] }
+      as, fs = *self.class.class_eval { [__attribute_sets, @attribute_filters] }
       return if fs.blank? || as.blank?
       as.each_pair { |set_name, o| send(fs[set_name]) if fs.has_key?(set_name) }
       nil
@@ -107,7 +107,7 @@ module ActiveModel
     # 
     # @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 = self.class.instance_variable_get(:@attribute_filters)
       f.nil? ? ActiveModel::MetaSet.new : f.dup
     end
 

data/lib/attribute-filters/dsl_attr_virtual.rb

@@ -12,8 +12,48 @@ module ActiveModel
   module AttributeFilters
     module ClassMethods
 
+      unless method_defined?(:method_added)
+        def method_added(x); end
+      end
+
+      # @private
+      def method_added_with_afv(method_name)
+        method_name = method_name.to_s
+        if method_name[-1] == '='
+          atr_name = method_name[0..-2]
+          have_writer = true
+        else
+          atr_name = method_name
+          have_writer = false
+        end
+        a = __attribute_filters_virtual[atr_name]
+        if a && a != :no_wrap
+          if have_writer && method_defined?(atr_name) || !have_writer && method_defined?("#{atr_name}=")
+            wrap_virtual_attribute_writer(atr_name)
+          end
+        end
+        method_added_without_afv(method_name)
+      end
+      alias_method :method_added_without_afv, :method_added
+      alias_method :method_added, :method_added_with_afv
+
       private
 
+      def wrap_virtual_attribute_writer(atr_name)
+        writer_name = "#{atr_name}=".to_sym
+        writer_name_wct = "#{atr_name}_without_ct"
+        __attribute_filters_virtual[atr_name] = false
+        alias_method(writer_name_wct, writer_name)
+        class_eval <<-EVAL
+          def #{writer_name}(val)
+            attribute_will_change!('#{atr_name}') if val != #{atr_name}
+            #{writer_name_wct}(val)
+          end
+        EVAL
+        __attribute_filters_virtual[atr_name] = :tracked
+        nil
+      end
+
       unless method_defined?(:attr_virtual)
         # This method creates setter and getter for attributes of the given names
         # and ensures that changes of their values are tracked.
@@ -22,30 +62,21 @@ module ActiveModel
         #  +attr_virtual+ will overwrite setter. Don't do that.
         def attr_virtual(*attribute_names)
           attribute_names.flatten.compact.uniq.each do |atr_name|
-            writer_name = "#{atr_name}="
-            atr_name = atr_name.to_sym
-            attr_reader(atr_name) unless method_defined?(atr_name)
-            treat_as_virtual(atr_name)
-            if method_defined?(writer_name)
-              self.class_eval <<-EVAL
-                alias_method :#{atr_name}_without_change_tracking=, :#{writer_name}
-                def #{writer_name}(val)
-                  attribute_will_change!('#{atr_name}') if val != '#{atr_name}'
-                  #{atr_name}_without_change_tracking=(val)
-                end
-              EVAL
+            atr_name = atr_name.to_s
+            writer_name = "#{atr_name}=".to_sym
+            if method_defined?(writer_name) && method_defined?(atr_name)
+              unless __attribute_filters_virtual.key?(atr_name)
+                wrap_virtual_attribute_writer(atr_name)
+              end
             else
-              self.class_eval <<-EVAL
-                def #{writer_name}(val)
-                  attribute_will_change!('#{atr_name}') if val != '#{atr_name}'
-                  @#{atr_name} = val
-                end
-              EVAL
+              __attribute_filters_virtual[atr_name] = :waiting
             end
           end
           nil
         end # def attr_virtual
+        alias_method :has_virtual_attribute, :attr_virtual
       end # unless method_defined?(:attr_virtual)
+
     end # module ClassMethods
   end # module AttributeFilters
 end # module ActiveModel

data/lib/attribute-filters/dsl_sets.rb

@@ -454,7 +454,7 @@ module ActiveModel
       #   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
+      #   @note This method may be used directly ONLY 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
@@ -467,7 +467,9 @@ module ActiveModel
       #   @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 }
+        args.flatten.compact.each do |atr|
+          __attribute_filters_virtual[atr.to_s] = :no_wrap
+        end
         nil
       end
       alias_method :attribute_filters_virtual,    :treat_as_virtual
@@ -479,20 +481,24 @@ module ActiveModel
 
       private
 
+      def __attribute_sets_meta
+        @attribute_sets ||= MetaSet.new
+      end
+
       def __attribute_filters_semi_real
-        @__attribute_filters_semi_real ||= ActiveModel::AttributeSet.new
+        __attribute_sets_meta[:semi_real] ||= ActiveModel::AttributeSet.new
       end
 
       def __attribute_filters_virtual
-        @__attribute_filters_virtual ||= ActiveModel::AttributeSet.new
+        __attribute_sets_meta[:virtual] ||= ActiveModel::AttributeSet.new
       end
 
       def __attributes_to_sets_map
-        @__attributes_to_sets_map ||= MetaSet.new(ActiveModel::MetaSet.new.freeze)
+        __attribute_sets_meta[:attrs] ||= MetaSet.new(ActiveModel::MetaSet.new.freeze)
       end
 
       def __attribute_sets
-        @__attribute_sets ||= MetaSet.new(ActiveModel::AttributeSet.new.freeze)
+        __attribute_sets_meta[:sets] ||= MetaSet.new(ActiveModel::AttributeSet.new.freeze)
       end
 
       def add_atrs_to_set(set_name, *atrs)

data/lib/attribute-filters/meta_set.rb

@@ -12,17 +12,8 @@ module ActiveModel
   # This is a kind of AttributeSet class
   # but its purpose it so store other information
   # than attribute names.
-  class MetaSet < AttributeSet
-
-    # @private
-    def initialize(*args)
-      Hash.instance_method(:initialize).bind(self).call(*args)
-    end
-
-    # @private
-    def inspect(*args)
-      Hash.instance_method(:inspect).bind(self).call(*args)
-    end
+  class MetaSet < Hash
+    include AttributeFilters::AttributeSetMethods
 
     private
 

data/lib/attribute-filters/version.rb

@@ -14,11 +14,11 @@ module ActiveModel
     # @private
     EMAIL       = 'pw@gnu.org'
     # @private
-    VERSION     = '2.0.0'
+    VERSION     = '2.0.1'
     # @private
     NAME        = 'attribute-filters'
     # @private
-    SUMMARY     = 'Concise way of filtering model attributes in Rails'
+    SUMMARY     = 'Concise way of filtering and grouping model attributes in Rails'
     # @private
     URL         = 'https://rubygems.org/gems/attribute-filters/'
     # @private

data/spec/attribute-filters_spec.rb

@@ -180,13 +180,14 @@ describe ActiveModel::AttributeFilters do
     before do
       TestModel.class_eval do
         include ActiveModel::AttributeFilters::Common
-        @__attribute_sets = nil
+        #@__attribute_sets = nil
+        @attribute_sets = nil
       end
       @tm = TestModel.new
     end
 
     after do
-      TestModel.class_eval{@__attribute_sets = nil}
+      TestModel.class_eval{@attribute_sets = nil}
       @tm.attributes_that(:should_be_splitted).should be_empty
       @tm.attributes_that(:should_be_joined).should be_empty
       @tm.attributes_that(:should_be_splitted).annotation(:real_name).should == nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: attribute-filters
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -36,7 +36,7 @@ cert_chain:
   YzBobXpodlZadEJ3ZlpyaXRTVmhmQ0xwNXVGd3FDcVkKTkszVElaYVBDaDFT
   Mi9FUzZ3WE52alErNUVuRUVMOWovcFNFb3A5RFlFQlBhTTJXRFZSNWkwakpU
   QWFSV3c9PQotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
-date: 2012-11-01 00:00:00.000000000 Z
+date: 2012-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -320,7 +320,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3287018804216042017
+      hash: -1229665950453395191
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -332,5 +332,5 @@ rubyforge_project: attribute-filters
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Concise way of filtering model attributes in Rails
+summary: Concise way of filtering and grouping model attributes in Rails
 test_files: []