dynamic_attributes 1.0.1 → 1.1.0

data/README.rdoc

@@ -1,11 +1,34 @@
 = dynamic_attributes
 
-dynamic_attributes is a gem that lets you dynamically specify attributes on ActiveRecord models, which will be serialized and
-deserialized to a given text column.
+dynamic_attributes is a gem that lets you dynamically specify attributes on ActiveRecord models, which will be serialized and deserialized to a given text column. Example:
+
+    >> dm = DynamicModel.new(:field_test => 'I am a dynamic attribute')
+      +-------+-------------+--------------------------------------------+
+      | title | description | dynamic_attributes                         |
+      +-------+-------------+--------------------------------------------+
+      |       |             | {"field_test"=>"I am a dynamic_attribute"} |
+      +-------+-------------+--------------------------------------------+
+    >> dm.field_test
+      => "I am a dynamic_attribute"
+    >> dm.field_test2
+      NoMethodError: undefined method `field_test2'
+    >> dm.field_test2 = 'I am too!'
+      => 'I am too!'
+    >> dm.field_test2
+      => 'I am too!'
+    >> dm.save
+      +-------+-------------+------------------------------------------------------------------------+
+      | title | description | dynamic_attributes                                                     |
+      +-------+-------------+------------------------------------------------------------------------+
+      |       |             | {"field_test2"=>"I am too!", "field_test"=>"I am a dynamic_attribute"} |
+      +-------+-------------+------------------------------------------------------------------------+
+          
+
+
 
 == Requirements
 
-* Rails 2.x
+* Rails 2.x / 3
 
 == Installation
 
@@ -39,10 +62,22 @@ To add dynamic_attributes to an AR model, take the following steps:
   - New: DynamicModel.new(:title => 'Hello', :field_summary => 'This is a dynamic attribute')
   - Create: DynamicModel.create(:title => 'Hello', :field_summary => 'This is a dynamic attribute')
   - Update: 
-    * dynamic_model.update_atribute(:field_summary, 'This is a dynamic attribute')
-    * dynamic_model.update_atributes(:field_summary => 'This is a dynamic attribute', :description => 'Testing')
+    * dynamic_model.update_attribute(:field_summary, 'This is a dynamic attribute')
+    * dynamic_model.update_attributes(:field_summary => 'This is a dynamic attribute', :description => 'Testing')
   - Set manually: dynamic_model.field_summary = 'This is a dynamic attribute'
   
+Note that a dynamic attribute should be prefixed (by default with 'field_'), see the Options section for more info. 
+
+* Get Info:
+  * dynamic_model.persisting_dynamic_attributes
+    * Returns an array of the dynamic attributes that will be persisted.
+  * DynamicModel.dynamic_attribute_field
+    * Returns the serialization attribute. You can access this serialization attribute directly if you need to.
+  * DynamicModel.dynamic_attribute_prefix
+    * Returns the method prefix of dynamic attributes, see below for more info.
+  * DynamicModel.destroy_dynamic_attribute_for_nil
+    * Returns whether dynamic attributes with null values will be persisted, see below for more info.
+      
 == Options
 
 The has_dynamic_attribute call takes three different options:

data/Rakefile

@@ -5,9 +5,9 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "dynamic_attributes"
-    gem.summary = %Q{Dynamic attributes is a gem that lets you dynamically specify attributes on ActiveRecord models, which will be serialized and
+    gem.summary = %Q{dynamic_attributes is a gem that lets you dynamically specify attributes on ActiveRecord models, which will be serialized and
 deserialized to a given text column.}
-    gem.description = %Q{Dynamic attributes is a gem that lets you dynamically specify attributes on ActiveRecord models, which will be serialized and
+    gem.description = %Q{dynamic_attributes is a gem that lets you dynamically specify attributes on ActiveRecord models, which will be serialized and
 deserialized to a given text column. Dynamic attributes can be defined by simply setting an attribute or by passing them on create or update.}
     gem.email = "r.j.delange@nedforce.nl"
     gem.homepage = "http://github.com/moiristo/dynamic_attributes"

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.1.0

data/lib/dynamic_attributes.rb

@@ -18,16 +18,24 @@ class << ActiveRecord::Base
     self.dynamic_attribute_prefix = options[:dynamic_attribute_prefix] || 'field_'
     cattr_accessor :destroy_dynamic_attribute_for_nil
     self.destroy_dynamic_attribute_for_nil = options[:destroy_dynamic_attribute_for_nil] || false    
-    
-    include DynamicAttributes    
+
+    include DynamicAttributes 
   end
 end
 
 # The DynamicAttributes module handles all dynamic attributes.
 module DynamicAttributes
-  
+
+    # Overrides the initializer to take dynamic attributes into account
+    def initialize(attributes = nil)
+      dynamic_attributes = {}
+      (attributes ||= {}).each{|att,value| dynamic_attributes[att] = value if att.to_s.starts_with?(self.dynamic_attribute_prefix) }
+      super(attributes.except(*dynamic_attributes.keys))   
+      set_dynamic_attributes(dynamic_attributes)    
+    end
+      
     # On saving an AR record, the attributes to be persisted are re-evaluated and written to the serialization field. 
-    def before_save
+    def evaluate_dynamic_attributes
       new_dynamic_attributes = {}
       self.persisting_dynamic_attributes.uniq.each do |dynamic_attribute| 
         value = send(dynamic_attribute)
@@ -40,24 +48,14 @@ module DynamicAttributes
       end
       write_attribute(self.dynamic_attribute_field, new_dynamic_attributes)
     end
-
+    
     # After find, populate the dynamic attributes and create accessors
-    def after_find
+    def populate_dynamic_attributes
       (read_attribute(self.dynamic_attribute_field) || {}).each {|att, value| set_dynamic_attribute(att, value); self.destroy_dynamic_attribute_for_nil = false if value.nil? }
     end
-
-    # Creates an accessor when a non-existing setter with the configured dynamic attribute prefix is detected. Calls super otherwise.
-    def method_missing(method, *arguments, &block) 
-      (method.to_s =~ /#{self.dynamic_attribute_prefix}(.+)=/) ? set_dynamic_attribute(self.dynamic_attribute_prefix + $1, *arguments.first) : super
-    end 
     
-    # Overrides the initializer to take dynamic attributes into account
-    def initialize(attributes = nil)
-      dynamic_attributes = {}
-      (attributes ||= {}).each{|att,value| dynamic_attributes[att] = value if att.to_s.starts_with?(self.dynamic_attribute_prefix) }
-      super(attributes.except(*dynamic_attributes.keys))   
-      set_dynamic_attributes(dynamic_attributes)    
-    end
+    # Explicitly define after_find for Rails 2.x
+    def after_find; populate_dynamic_attributes end    
 
     # Overrides update_attributes to take dynamic attributes into account
     def update_attributes(attributes)  
@@ -65,6 +63,11 @@ module DynamicAttributes
       super(attributes)
     end
     
+    # Creates an accessor when a non-existing setter with the configured dynamic attribute prefix is detected. Calls super otherwise.
+    def method_missing(method, *arguments, &block) 
+      (method.to_s =~ /#{self.dynamic_attribute_prefix}(.+)=/) ? set_dynamic_attribute(self.dynamic_attribute_prefix + $1, *arguments.first) : super
+    end     
+    
     # Returns the dynamic attributes that will be persisted to the serialization column. This array can
     # be altered to force dynamic attributes to not be saved in the database or to persist other attributes, but
     # it is recommended to not change it at all.
@@ -74,6 +77,9 @@ module DynamicAttributes
     
     # Ensures the configured dynamic attribute field is serialized by AR.
     def self.included object
+      super
+      object.after_find  :populate_dynamic_attributes         
+      object.before_save :evaluate_dynamic_attributes    
       object.serialize object.dynamic_attribute_field
     end
 

data/test/helper.rb

@@ -5,6 +5,7 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 gem "activerecord"
+require 'FileUtils'
 require 'active_record'
 require 'dynamic_attributes'
 require 'pp'
@@ -15,7 +16,7 @@ end
 
 def load_schema
   config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
-  ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+  ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new(File.dirname(__FILE__) + "/debug.log")
   db_adapter = ENV['DB']
   # no db passed, try one of these fine config-free DBs before bombing.
   db_adapter ||= begin

data/test/test_dynamic_attributes.rb

@@ -77,7 +77,7 @@ class TestDynamicAttributes < Test::Unit::TestCase
   def test_should_allow_different_serialization_field
     DynamicModel.dynamic_attribute_field = 'extra'
     @dynamic_model.update_attributes(:title => 'Title', :field_test1 => 'Hello', :field_test2 => 'World')
-    assert_equal({}, @dynamic_model.dynamic_attributes)
+    assert_equal({}, @dynamic_model.dynamic_attributes || {})
     assert_equal({"field_test1"=>"Hello", "field_test2"=>"World"}, @dynamic_model.extra)
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
-  - 0
   - 1
-  version: 1.0.1
+  - 0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Reinier de Lange
@@ -14,12 +14,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-29 00:00:00 +02:00
+date: 2010-09-07 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
 description: |-
-  Dynamic attributes is a gem that lets you dynamically specify attributes on ActiveRecord models, which will be serialized and
+  dynamic_attributes is a gem that lets you dynamically specify attributes on ActiveRecord models, which will be serialized and
   deserialized to a given text column. Dynamic attributes can be defined by simply setting an attribute or by passing them on create or update.
 email: r.j.delange@nedforce.nl
 executables: []
@@ -67,7 +67,7 @@ rubyforge_project:
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: Dynamic attributes is a gem that lets you dynamically specify attributes on ActiveRecord models, which will be serialized and deserialized to a given text column.
+summary: dynamic_attributes is a gem that lets you dynamically specify attributes on ActiveRecord models, which will be serialized and deserialized to a given text column.
 test_files: 
 - test/helper.rb
 - test/test_dynamic_attributes.rb