activerecord 1.15.6 → 2.0.0

data/README

@@ -176,7 +176,7 @@ A short rundown of the major features:
    )
 
   {Learn more}[link:classes/ActiveRecord/Base.html#M000081] and read about the built-in support for
-  MySQL[link:classes/ActiveRecord/ConnectionAdapters/MysqlAdapter.html], PostgreSQL[link:classes/ActiveRecord/ConnectionAdapters/PostgreSQLAdapter.html], SQLite[link:classes/ActiveRecord/ConnectionAdapters/SQLiteAdapter.html], Oracle[link:classes/ActiveRecord/ConnectionAdapters/OCIAdapter.html], SQLServer[link:classes/ActiveRecord/ConnectionAdapters/SQLServerAdapter.html], and DB2[link:classes/ActiveRecord/ConnectionAdapters/DB2Adapter.html].
+  MySQL[link:classes/ActiveRecord/ConnectionAdapters/MysqlAdapter.html], PostgreSQL[link:classes/ActiveRecord/ConnectionAdapters/PostgreSQLAdapter.html], SQLite[link:classes/ActiveRecord/ConnectionAdapters/SQLiteAdapter.html], Oracle[link:classes/ActiveRecord/ConnectionAdapters/OracleAdapter.html], SQLServer[link:classes/ActiveRecord/ConnectionAdapters/SQLServerAdapter.html], and DB2[link:classes/ActiveRecord/ConnectionAdapters/DB2Adapter.html].
 
 
 * Logging support for Log4r[http://log4r.sourceforge.net] and Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc]

data/RUNNING_UNIT_TESTS

@@ -23,42 +23,11 @@ Rake can be found at http://rake.rubyforge.org
 == Running by hand
 
 Unit tests are located in test directory. If you only want to run a single test suite, 
-or don't want to bother with Rake, you can do so with something like:
+you can do so with:
 
-   cd test; ruby -I "connections/native_mysql" base_test.rb
+   rake test_mysql TEST=base_test.rb
    
-That'll run the base suite using the MySQL-Ruby adapter. Change the adapter
-and test suite name as needed.
+That'll run the base suite using the MySQL-Ruby adapter.
 
-You can also run all the suites on a specific adapter with:
 
-   cd test; all.sh "connections/native_mysql"
-
-== Faster tests
-
-If you are using a database that supports transactions, you can set the
-"AR_TX_FIXTURES" environment variable to "yes" to use transactional fixtures.
-This gives a very large speed boost. With rake:
-
-  rake AR_TX_FIXTURES=yes
-
-Or, by hand:
-
-  AR_TX_FIXTURES=yes ruby -I connections/native_sqlite3 base_test.rb
-
-== Testing with Oracle
-
-In order to allow for testing against Oracle using an "arunit" schema within an existing
-Oracle database, the database name and tns connection string must be set in environment
-variables prior to running the unit tests.
-
-  $ export ARUNIT_DB_NAME=MYDB
-  $ export ARUNIT_DB=MYDB
-
-The ARUNIT_DB_NAME variable should be set to the name by which the database knows
-itself, ie., what will be returned by the query:
-
-  select sys_context('userenv','db_name') db from dual
-
-And the ARUNIT_DB variable should be set to the tns connection string.
 

data/Rakefile

@@ -22,106 +22,127 @@ PKG_FILES = FileList[
 ].exclude(/\bCVS\b|~$/)
 
 
-desc "Default Task"
-task :default => [ :test_mysql, :test_sqlite, :test_postgresql ]
+desc 'Run mysql, sqlite, and postgresql tests by default'
+task :default => :test
 
-# Run the unit tests
+desc 'Run mysql, sqlite, and postgresql tests'
+task :test => %w(test_mysql test_sqlite test_sqlite3 test_postgresql)
 
-for adapter in %w( mysql postgresql sqlite sqlite3 firebird sqlserver sqlserver_odbc db2 oracle sybase openbase frontbase )
+for adapter in %w( mysql postgresql sqlite sqlite3 firebird db2 oracle sybase openbase frontbase )
   Rake::TestTask.new("test_#{adapter}") { |t|
     t.libs << "test" << "test/connections/native_#{adapter}"
-    if adapter =~ /^sqlserver/
-      t.pattern = "test/**/*_test{,_sqlserver}.rb"
-    else
-      t.pattern = "test/**/*_test{,_#{adapter}}.rb"
-    end
+    adapter_short = adapter == 'db2' ? adapter : adapter[/^[a-z]+/]
+    t.pattern = "test/**/*_test{,_#{adapter_short}}.rb"
     t.verbose = true
   }
+
+  namespace adapter do
+    task :test => "test_#{adapter}"
+  end
 end
 
 SCHEMA_PATH = File.join(File.dirname(__FILE__), *%w(test fixtures db_definitions))
 
-desc 'Build the MySQL test databases'
-task :build_mysql_databases do 
-  %x( mysqladmin  create activerecord_unittest )
-  %x( mysqladmin  create activerecord_unittest2 )
-  %x( mysql -e "grant all on activerecord_unittest.* to rails@localhost" )
-  %x( mysql -e "grant all on activerecord_unittest2.* to rails@localhost" )
-  %x( mysql  activerecord_unittest < #{File.join(SCHEMA_PATH, 'mysql.sql')} )
-  %x( mysql  activerecord_unittest < #{File.join(SCHEMA_PATH, 'mysql2.sql')} )
-end
+namespace :mysql do
+  desc 'Build the MySQL test databases'
+  task :build_databases do
+    %x( mysqladmin  create activerecord_unittest )
+    %x( mysqladmin  create activerecord_unittest2 )
+    %x( mysql -e "grant all on activerecord_unittest.* to rails@localhost" )
+    %x( mysql -e "grant all on activerecord_unittest2.* to rails@localhost" )
+  end
+
+  desc 'Drop the MySQL test databases'
+  task :drop_databases do
+    %x( mysqladmin -f drop activerecord_unittest )
+    %x( mysqladmin -f drop activerecord_unittest2 )
+  end
 
-desc 'Drop the MySQL test databases'
-task :drop_mysql_databases do 
-  %x( mysqladmin -f drop activerecord_unittest )
-  %x( mysqladmin -f drop activerecord_unittest2 )
+  desc 'Rebuild the MySQL test databases'
+  task :rebuild_databases => [:drop_databases, :build_databases]
 end
 
-desc 'Rebuild the MySQL test databases'
-task :rebuild_mysql_databases => [:drop_mysql_databases, :build_mysql_databases]
+task :build_mysql_databases => 'mysql:build_databases'
+task :drop_mysql_databases => 'mysql:drop_databases'
+task :rebuild_mysql_databases => 'mysql:rebuild_databases'
 
-desc 'Build the PostgreSQL test databases'
-task :build_postgresql_databases do 
-  %x( createdb -U postgres activerecord_unittest )
-  %x( createdb -U postgres activerecord_unittest2 )
-  %x( psql activerecord_unittest -f #{File.join(SCHEMA_PATH, 'postgresql.sql')} postgres )
-  %x( psql activerecord_unittest2 -f #{File.join(SCHEMA_PATH, 'postgresql2.sql')}  postgres )
-end
 
-desc 'Drop the PostgreSQL test databases'
-task :drop_postgresql_databases do 
-  %x( dropdb -U postgres activerecord_unittest )
-  %x( dropdb -U postgres activerecord_unittest2 )
+namespace :postgresql do
+  desc 'Build the PostgreSQL test databases'
+  task :build_databases do
+    %x( createdb -U postgres activerecord_unittest )
+    %x( createdb -U postgres activerecord_unittest2 )
+    %x( psql activerecord_unittest -f #{File.join(SCHEMA_PATH, 'postgresql.sql')} postgres )
+    %x( psql activerecord_unittest2 -f #{File.join(SCHEMA_PATH, 'postgresql2.sql')}  postgres )
+  end
+
+  desc 'Drop the PostgreSQL test databases'
+  task :drop_databases do
+    %x( dropdb -U postgres activerecord_unittest )
+    %x( dropdb -U postgres activerecord_unittest2 )
+  end
+
+  desc 'Rebuild the PostgreSQL test databases'
+  task :rebuild_databases => [:drop_databases, :build_databases]
 end
 
-desc 'Rebuild the PostgreSQL test databases'
-task :rebuild_postgresql_databases => [:drop_postgresql_databases, :build_postgresql_databases]
+task :build_postgresql_databases => 'postgresql:build_databases'
+task :drop_postgresql_databases => 'postgresql:drop_databases'
+task :rebuild_postgresql_databases => 'postgresql:rebuild_databases'
 
-desc 'Build the FrontBase test databases'
-task :build_frontbase_databases => :rebuild_frontbase_databases 
 
-desc 'Rebuild the FrontBase test databases'
-task :rebuild_frontbase_databases do
-  build_frontbase_database = Proc.new do |db_name, sql_definition_file|
-    %(
-      STOP DATABASE #{db_name};
-      DELETE DATABASE #{db_name};
-      CREATE DATABASE #{db_name};
+namespace :frontbase do
+  desc 'Build the FrontBase test databases'
+  task :build_databases => :rebuild_frontbase_databases
 
-      CONNECT TO #{db_name} AS SESSION_NAME USER _SYSTEM;
-      SET COMMIT FALSE;
+  desc 'Rebuild the FrontBase test databases'
+  task :rebuild_databases do
+    build_frontbase_database = Proc.new do |db_name, sql_definition_file|
+      %(
+        STOP DATABASE #{db_name};
+        DELETE DATABASE #{db_name};
+        CREATE DATABASE #{db_name};
 
-      CREATE USER RAILS;
-      CREATE SCHEMA RAILS AUTHORIZATION RAILS;
-      COMMIT;
+        CONNECT TO #{db_name} AS SESSION_NAME USER _SYSTEM;
+        SET COMMIT FALSE;
 
-      SET SESSION AUTHORIZATION RAILS;
-      SCRIPT '#{sql_definition_file}';
+        CREATE USER RAILS;
+        CREATE SCHEMA RAILS AUTHORIZATION RAILS;
+        COMMIT;
 
-      COMMIT;
+        SET SESSION AUTHORIZATION RAILS;
+        SCRIPT '#{sql_definition_file}';
 
-      DISCONNECT ALL; 
-    )
-  end
-  create_activerecord_unittest  = build_frontbase_database['activerecord_unittest',  File.join(SCHEMA_PATH, 'frontbase.sql')]
-  create_activerecord_unittest2 = build_frontbase_database['activerecord_unittest2', File.join(SCHEMA_PATH, 'frontbase2.sql')]
-  execute_frontbase_sql = Proc.new do |sql| 
-    system(<<-SHELL)
-    /Library/FrontBase/bin/sql92 <<-SQL
-    #{sql}
-    SQL
-    SHELL
+        COMMIT;
+
+        DISCONNECT ALL;
+      )
+    end
+    create_activerecord_unittest  = build_frontbase_database['activerecord_unittest',  File.join(SCHEMA_PATH, 'frontbase.sql')]
+    create_activerecord_unittest2 = build_frontbase_database['activerecord_unittest2', File.join(SCHEMA_PATH, 'frontbase2.sql')]
+    execute_frontbase_sql = Proc.new do |sql|
+      system(<<-SHELL)
+      /Library/FrontBase/bin/sql92 <<-SQL
+      #{sql}
+      SQL
+      SHELL
+    end
+    execute_frontbase_sql[create_activerecord_unittest]
+    execute_frontbase_sql[create_activerecord_unittest2]
   end
-  execute_frontbase_sql[create_activerecord_unittest]
-  execute_frontbase_sql[create_activerecord_unittest2]
 end
 
+task :build_frontbase_databases => 'frontbase:build_databases'
+task :rebuild_frontbase_databases => 'frontbase:rebuild_databases'
+
+
 # Generate the RDoc documentation
 
 Rake::RDocTask.new { |rdoc|
   rdoc.rdoc_dir = 'doc'
   rdoc.title    = "Active Record -- Object-relation mapping put on rails"
   rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+  rdoc.options << '--charset' << 'utf-8'
   rdoc.template = "#{ENV['template']}.rb" if ENV['template']
   rdoc.rdoc_files.include('README', 'RUNNING_UNIT_TESTS', 'CHANGELOG')
   rdoc.rdoc_files.include('lib/**/*.rb')
@@ -138,7 +159,7 @@ end
 
 # Create compressed packages
 
-dist_dirs = [ "lib", "test", "examples", "dev-utils" ]
+dist_dirs = [ "lib", "test", "examples" ]
 
 spec = Gem::Specification.new do |s|
   s.name = PKG_NAME
@@ -150,8 +171,8 @@ spec = Gem::Specification.new do |s|
   dist_dirs.each do |dir|
     s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
   end
-  
-  s.add_dependency('activesupport', '= 1.4.4' + PKG_BUILD)
+
+  s.add_dependency('activesupport', '= 2.0.0' + PKG_BUILD)
 
   s.files.delete "test/fixtures/fixture_database.sqlite"
   s.files.delete "test/fixtures/fixture_database_2.sqlite"
@@ -163,13 +184,13 @@ spec = Gem::Specification.new do |s|
   s.has_rdoc = true
   s.extra_rdoc_files = %w( README )
   s.rdoc_options.concat ['--main',  'README']
-  
+
   s.author = "David Heinemeier Hansson"
   s.email = "david@loudthinking.com"
   s.homepage = "http://www.rubyonrails.org"
   s.rubyforge_project = "activerecord"
 end
-  
+
 Rake::GemPackageTask.new(spec) do |p|
   p.gem_spec = spec
   p.need_tar = true
@@ -190,10 +211,10 @@ task :lines do
       codelines += 1
     end
     puts "L: #{sprintf("%4d", lines)}, LOC #{sprintf("%4d", codelines)} | #{file_name}"
-    
+
     total_lines     += lines
     total_codelines += codelines
-    
+
     lines, codelines = 0, 0
   end
 
@@ -204,13 +225,13 @@ end
 # Publishing ------------------------------------------------------
 
 desc "Publish the beta gem"
-task :pgem => [:package] do 
+task :pgem => [:package] do
   Rake::SshFilePublisher.new("davidhh@wrath.rubyonrails.org", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
   `ssh davidhh@wrath.rubyonrails.org './gemupdate.sh'`
 end
 
 desc "Publish the API documentation"
-task :pdoc => [:rdoc] do 
+task :pdoc => [:rdoc] do
   Rake::SshDirPublisher.new("davidhh@wrath.rubyonrails.org", "public_html/ar", "doc").upload
 end
 
@@ -223,4 +244,4 @@ task :release => [ :package ] do
   rubyforge = RubyForge.new
   rubyforge.login
   rubyforge.add_release(PKG_NAME, PKG_NAME, "REL #{PKG_VERSION}", *packages)
-end
+end

data/install.rb

@@ -18,7 +18,7 @@ unless $sitedir
   end
 end
 
-# the acual gruntwork
+# the actual gruntwork
 Dir.chdir("lib")
 
 Find.find("active_record", "active_record.rb") { |f|

data/lib/active_record.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004-2006 David Heinemeier Hansson
+# Copyright (c) 2004-2007 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -24,18 +24,21 @@
 $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-unless defined?(ActiveSupport)
-  begin
-    $:.unshift(File.dirname(__FILE__) + "/../../activesupport/lib")  
-    require 'active_support'  
-  rescue LoadError
+unless defined? ActiveSupport
+  active_support_path = File.dirname(__FILE__) + "/../../activesupport/lib"
+  if File.exist?(active_support_path)
+    $:.unshift active_support_path
+    require 'active_support'
+  else
     require 'rubygems'
     gem 'activesupport'
+    require 'active_support'
   end
 end
 
 require 'active_record/base'
 require 'active_record/observer'
+require 'active_record/query_cache'
 require 'active_record/validations'
 require 'active_record/callbacks'
 require 'active_record/reflection'
@@ -43,18 +46,16 @@ require 'active_record/associations'
 require 'active_record/aggregations'
 require 'active_record/transactions'
 require 'active_record/timestamp'
-require 'active_record/acts/list'
-require 'active_record/acts/tree'
-require 'active_record/acts/nested_set'
 require 'active_record/locking/optimistic'
 require 'active_record/locking/pessimistic'
 require 'active_record/migration'
 require 'active_record/schema'
 require 'active_record/calculations'
-require 'active_record/xml_serialization'
+require 'active_record/serialization'
 require 'active_record/attribute_methods'
 
 ActiveRecord::Base.class_eval do
+  extend ActiveRecord::QueryCache
   include ActiveRecord::Validations
   include ActiveRecord::Locking::Optimistic
   include ActiveRecord::Locking::Pessimistic
@@ -65,21 +66,11 @@ ActiveRecord::Base.class_eval do
   include ActiveRecord::Aggregations
   include ActiveRecord::Transactions
   include ActiveRecord::Reflection
-  include ActiveRecord::Acts::Tree
-  include ActiveRecord::Acts::List
-  include ActiveRecord::Acts::NestedSet
   include ActiveRecord::Calculations
-  include ActiveRecord::XmlSerialization
+  include ActiveRecord::Serialization
   include ActiveRecord::AttributeMethods
 end
 
-unless defined?(RAILS_CONNECTION_ADAPTERS)
-  RAILS_CONNECTION_ADAPTERS = %w( mysql postgresql sqlite firebird sqlserver db2 oracle sybase openbase frontbase )
-end
+require 'active_record/connection_adapters/abstract_adapter'
 
-RAILS_CONNECTION_ADAPTERS.each do |adapter|
-  require "active_record/connection_adapters/" + adapter + "_adapter"
-end
-
-require 'active_record/query_cache'
 require 'active_record/schema_dumper'

data/lib/active_record/aggregations.rb

@@ -70,7 +70,7 @@ module ActiveRecord
     #  end
     #  
     # Now it's possible to access attributes from the database through the value objects instead. If you choose to name the
-    # composition the same as the attributes name, it will be the only way to access that attribute. That's the case with our
+    # composition the same as the attribute's name, it will be the only way to access that attribute. That's the case with our
     # +balance+ attribute. You interact with the value objects just like you would any other attribute, though:
     #
     #   customer.balance = Money.new(20)     # sets the Money value object and the attribute
@@ -92,19 +92,19 @@ module ActiveRecord
     #
     # == Writing value objects
     #
-    # Value objects are immutable and interchangeable objects that represent a given value, such as a Money object representing
-    # $5. Two Money objects both representing $5 should be equal (through methods such as == and <=> from Comparable if ranking
-    # makes sense). This is unlike entity objects where equality is determined by identity. An entity class such as Customer can
+    # Value objects are immutable and interchangeable objects that represent a given value, such as a +Money+ object representing
+    # $5. Two +Money+ objects both representing $5 should be equal (through methods such as == and <=> from +Comparable+ if ranking
+    # makes sense). This is unlike entity objects where equality is determined by identity. An entity class such as +Customer+ can
     # easily have two different objects that both have an address on Hyancintvej. Entity identity is determined by object or
-    # relational unique identifiers (such as primary keys). Normal ActiveRecord::Base classes are entity objects.
+    # relational unique identifiers (such as primary keys). Normal <tt>ActiveRecord::Base</tt> classes are entity objects.
     #
-    # It's also important to treat the value objects as immutable. Don't allow the Money object to have its amount changed after
-    # creation. Create a new money object with the new value instead. This is exemplified by the Money#exchanged_to method that
+    # It's also important to treat the value objects as immutable. Don't allow the +Money+ object to have its amount changed after
+    # creation. Create a new +Money+ object with the new value instead. This is exemplified by the <tt>Money#exchanged_to</tt> method that
     # returns a new value object instead of changing its own values. Active Record won't persist value objects that have been
-    # changed through other means than the writer method.
+    # changed through means other than the writer method.
     #
     # The immutable requirement is enforced by Active Record by freezing any object assigned as a value object. Attempting to 
-    # change it afterwards will result in a TypeError.
+    # change it afterwards will result in a <tt>TypeError</tt>.
     # 
     # Read more about value objects on http://c2.com/cgi/wiki?ValueObject and on the dangers of not keeping value objects
     # immutable on http://c2.com/cgi/wiki?ValueObjectsShouldBeImmutable
@@ -119,71 +119,60 @@ module ActiveRecord
       # * <tt>:mapping</tt> - specifies a number of mapping arrays (attribute, parameter) that bind an attribute name
       #   to a constructor parameter on the value class.
       # * <tt>:allow_nil</tt> - specifies that the aggregate object will not be instantiated when all mapped
-      #   attributes are nil.  Setting the aggregate class to nil has the effect of writing nil to all mapped attributes.
-      #   This defaults to false.
+      #   attributes are +nil+.  Setting the aggregate class to +nil+ has the effect of writing +nil+ to all mapped attributes.
+      #   This defaults to +false+.
+      #
+      # An optional block can be passed to convert the argument that is passed to the writer method into an instance of
+      # <tt>:class_name</tt>. The block will only be called if the argument is not already an instance of <tt>:class_name</tt>.
       #
       # Option examples:
       #   composed_of :temperature, :mapping => %w(reading celsius)
-      #   composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
+      #   composed_of(:balance, :class_name => "Money", :mapping => %w(balance amount)) {|balance| balance.to_money }
       #   composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
       #   composed_of :gps_location
       #   composed_of :gps_location, :allow_nil => true
       #
-      def composed_of(part_id, options = {})
+      def composed_of(part_id, options = {}, &block)
         options.assert_valid_keys(:class_name, :mapping, :allow_nil)
 
         name        = part_id.id2name
         class_name  = options[:class_name] || name.camelize
         mapping     = options[:mapping]    || [ name, name ]
+        mapping     = [ mapping ] unless mapping.first.is_a?(Array)
         allow_nil   = options[:allow_nil]  || false
 
         reader_method(name, class_name, mapping, allow_nil)
-        writer_method(name, class_name, mapping, allow_nil)
+        writer_method(name, class_name, mapping, allow_nil, block)
         
         create_reflection(:composed_of, part_id, options, self)
       end
 
       private
         def reader_method(name, class_name, mapping, allow_nil)
-          mapping = (Array === mapping.first ? mapping : [ mapping ])
-
-          allow_nil_condition = if allow_nil
-            mapping.collect { |pair| "!read_attribute(\"#{pair.first}\").nil?"}.join(" && ")
-          else
-            "true"
-          end
-
-          module_eval <<-end_eval
-            def #{name}(force_reload = false)
-              if (@#{name}.nil? || force_reload) && #{allow_nil_condition}
-                @#{name} = #{class_name}.new(#{mapping.collect { |pair| "read_attribute(\"#{pair.first}\")"}.join(", ")})
+          module_eval do
+            define_method(name) do |*args|
+              force_reload = args.first || false
+              if (instance_variable_get("@#{name}").nil? || force_reload) && (!allow_nil || mapping.any? {|pair| !read_attribute(pair.first).nil? })
+                instance_variable_set("@#{name}", class_name.constantize.new(*mapping.collect {|pair| read_attribute(pair.first)}))
               end
-              return @#{name}
+              return instance_variable_get("@#{name}")
             end
-          end_eval
-        end        
-        
-        def writer_method(name, class_name, mapping, allow_nil)
-          mapping = (Array === mapping.first ? mapping : [ mapping ])
+          end
 
-          if allow_nil
-            module_eval <<-end_eval
-              def #{name}=(part)
-                if part.nil?
-                  #{mapping.collect { |pair| "@attributes[\"#{pair.first}\"] = nil" }.join("\n")}
-                else
-                  @#{name} = part.freeze
-                  #{mapping.collect { |pair| "@attributes[\"#{pair.first}\"] = part.#{pair.last}" }.join("\n")}
-                end
-              end
-            end_eval
-          else
-            module_eval <<-end_eval
-              def #{name}=(part)
-                @#{name} = part.freeze
-                #{mapping.collect{ |pair| "@attributes[\"#{pair.first}\"] = part.#{pair.last}" }.join("\n")}
+        end
+
+        def writer_method(name, class_name, mapping, allow_nil, conversion)
+          module_eval do
+            define_method("#{name}=") do |part|
+              if part.nil? && allow_nil
+                mapping.each { |pair| @attributes[pair.first] = nil }
+                instance_variable_set("@#{name}", nil)
+              else
+                part = conversion.call(part) unless part.is_a?(class_name.constantize) || conversion.nil?
+                mapping.each { |pair| @attributes[pair.first] = part.send(pair.last) }
+                instance_variable_set("@#{name}", part.freeze)
               end
-            end_eval
+            end
           end
         end
     end