vacuum_cleaner 1.0.1 → 1.0.3

data/lib/vacuum_cleaner.rb

@@ -9,7 +9,7 @@ require 'vacuum_cleaner/normalizations'
 # @see VacuumCleaner::Normalizer
 module VacuumCleaner
   # +VacuumCleaner+ version
-  VERSION = "1.0.1".freeze
+  VERSION = "1.0.3".freeze
 end
 
 if defined?(ActiveSupport) && ActiveSupport.respond_to?(:on_load)

data/lib/vacuum_cleaner/normalizations.rb

@@ -14,6 +14,17 @@ module VacuumCleaner
         
     module ClassMethods
       
+      # List of already normalized attributes, to keep everything safe
+      # when calling `normalizes` twice for a certain attribute.
+      #
+      # When called for the first time checks it's `superclass` for any
+      # normalized attributes.
+      def normalized_attributes
+        @normalized_attributes ||= [].tap do |ary|
+          superclass.normalized_attributes.each { |a| ary << a } if superclass && superclass.respond_to?(:normalized_attributes)
+        end
+      end
+      
       # Enables normalization chain for supplied attributes.
       #
       # @example Basic usage for plain old ruby objects.
@@ -35,8 +46,6 @@ module VacuumCleaner
       # @yield [instance, attribute, value] optional (extended) block with all arguments, like the +object+ and
       #        current +attribute+ name. Everything else behaves the same es the single-value +yield+
       def normalizes(*attributes, &block)
-        metaklass = class << self; self; end
-        
         normalizations = attributes.last.is_a?(Hash) ? attributes.pop : {}
         raise ArgumentError, "You need to supply at least one attribute" if attributes.empty?
         
@@ -53,23 +62,27 @@ module VacuumCleaner
         
         attributes.each do |attribute|
           attribute = attribute.to_sym
-          send(:define_method, :"normalize_#{attribute}") do |value|
-            value = normalizers.inject(value) { |v,n| n.normalize(self, attribute, v) }
-            block_given? ? (block.arity == 1 ? yield(value) : yield(self, attribute, value)) : value
-          end
-          original_setter = "#{attribute}#{VacuumCleaner::WITHOUT_NORMALIZATION_SUFFIX}=".to_sym
-          send(:alias_method, original_setter, "#{attribute}=") if instance_methods.include?(RUBY_VERSION =~ /^1.9/ ? :"#{attribute}=" : "#{attribute}=")
-                    
-          rb_src = <<-RUBY
-            def #{attribute}=(value)                                                                          #  1.  def name=(value)
-              value = send(:'normalize_#{attribute}', value)                                                  #  2.    value = send(:'normalize_name', value)
-              return send(#{original_setter.inspect}, value) if respond_to?(#{original_setter.inspect})       #  3.    return send(:'name_wi...=', value) if respond_to?(:'name_wi...=')
-              return self[#{attribute.inspect}] = value if respond_to?(:[]=)                                  #  4.    return self[:name] = value if respond_to?(:write_attribute)
-              @#{attribute} = value                                                                           #  5.   @name = value
-            end                                                                                               #  6.  end
-          RUBY
           
-          module_eval rb_src, __FILE__, __LINE__
+          # guard against calling it twice!
+          unless normalized_attributes.include?(attribute)
+            send(:define_method, :"normalize_#{attribute}") do |value|
+              value = normalizers.inject(value) { |v,n| n.normalize(self, attribute, v) }
+              block_given? ? (block.arity == 1 ? yield(value) : yield(self, attribute, value)) : value
+            end
+            original_setter = "#{attribute}#{VacuumCleaner::WITHOUT_NORMALIZATION_SUFFIX}=".to_sym
+            send(:alias_method, original_setter, "#{attribute}=") if instance_methods.include?(RUBY_VERSION =~ /^1.9/ ? :"#{attribute}=" : "#{attribute}=")
+                    
+            class_eval <<-RUBY, __FILE__, __LINE__+1
+              def #{attribute}=(value)                                                                          #  1.  def name=(value)
+                value = send(:'normalize_#{attribute}', value)                                                  #  2.    value = send(:'normalize_name', value)
+                return send(#{original_setter.inspect}, value) if respond_to?(#{original_setter.inspect})       #  3.    return send(:'name_wi...=', value) if respond_to?(:'name_wi...=')
+                return send(:[]=, #{attribute.inspect}, value) if respond_to?(:[]=)                             #  4.    return send(:[]=, :name, value) if respond_to?(:[]=)
+                @#{attribute} = value                                                                           #  5.   @name = value
+              end                                                                                               #  6.  end
+            RUBY
+            
+            normalized_attributes << attribute
+          end
         end
       end      
     end    

data/test/unit/vacuum_cleaner/normalizations_test.rb

@@ -191,5 +191,31 @@ class VacuumCleaner::NormalizationsTest < Test::Unit::TestCase
         assert_equal [obj.object_id, :name, "Carla"], obj.name
       end
     end
+    
+    context "ClassMethods#normalized_attributes" do
+      should "keep an array with all normalized attributes" do
+        assert_equal [:name], Doctor.normalized_attributes
+        assert_equal [:last_name, :first_name], Person.normalized_attributes
+      end
+      
+      should "guard against calling `normalizes` twice for an attribute, to avoid stack level too deep error!" do
+        klass = Class.new(Doctor) do
+          attr_accessor :coolness
+          normalizes :coolness, :downcase => true
+        end
+        
+        assert_equal [:name, :coolness], klass.normalized_attributes
+        assert_equal [:name], Doctor.normalized_attributes
+        
+        klass.send(:normalizes, :coolness, :upcase => true) # should be ignored!
+        assert_equal [:name, :coolness], klass.normalized_attributes
+        
+        obj = klass.new
+        assert_nothing_raised do
+          obj.coolness = "AWESOME"
+        end
+        assert_equal "awesome", obj.coolness
+      end
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: vacuum_cleaner
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 17
   prerelease: false
   segments: 
   - 1
   - 0
-  - 1
-  version: 1.0.1
+  - 3
+  version: 1.0.3
 platform: ruby
 authors: 
 - Lukas Westermann
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-09 00:00:00 +02:00
+date: 2010-10-07 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -71,7 +71,6 @@ files:
 - lib/vacuum_cleaner/normalizations/numeric.rb
 - lib/vacuum_cleaner/normalizations/url.rb
 - lib/vacuum_cleaner/normalizer.rb
-- lib/vacuum_cleaner/railtie.rb
 - test/integration/active_record_integration_test.rb
 - test/integration/active_support_integration_test.rb
 - test/test_helper.rb

data/lib/vacuum_cleaner/railtie.rb

@@ -1,7 +0,0 @@
-module VacuumCleaner
-  class Railtie < Rails::Railtie
-    config.after_initialize do
-      ActiveRecord::Base.send(:include, VacuumCleaner::Normalizations)
-    end
-  end
-end