datamapper 0.2.5 → 0.3.0

data/example.rb

@@ -1,27 +1,45 @@
 #!/usr/bin/env ruby
 
-ENV['LOG_NAME'] = 'example'
+ENV['LOG_NAME'] ||= 'example'
 require 'environment'
 
 # Define a fixtures helper method to load up our test data.
-def fixtures(name, force = false)
+def fixtures(name)
   entry = YAML::load_file(File.dirname(__FILE__) + "/spec/fixtures/#{name}.yaml")
-  klass = Kernel::const_get(Inflector.classify(Inflector.singularize(name)))
-  
-  klass.auto_migrate!
-  
-  (entry.kind_of?(Array) ? entry : [entry]).each do |hash|
-    if hash['type']
-      Object::const_get(hash['type'])::create(hash)
-    else
-      klass::create(hash)
+  klass = begin
+    Kernel::const_get(Inflector.classify(Inflector.singularize(name)))
+  rescue
+    nil
+  end
+
+  unless klass.nil?
+    database.logger.debug { "AUTOMIGRATE: #{klass}" }
+    klass.auto_migrate!
+
+    (entry.kind_of?(Array) ? entry : [entry]).each do |hash|
+      if hash['type']
+        Object::const_get(hash['type'])::create(hash)
+      else
+        klass::create(hash)
+      end
+    end
+  else
+    table = database.table(name.to_s)
+    table.create! true
+    table.activate_associations!
+
+    #pp database.schema
+
+    (entry.kind_of?(Array) ? entry : [entry]).each do |hash|
+      table.insert(hash)
     end
   end
 end
 
+
 # Pre-fill the database so non-destructive tests don't need to reload fixtures.
 Dir[File.dirname(__FILE__) + "/spec/fixtures/*.yaml"].each do |path|
-  fixtures(File::basename(path).sub(/\.yaml$/, ''), true)
+  fixtures(File::basename(path).sub(/\.yaml$/, ''))
 end
 
 require 'irb'

data/lib/data_mapper.rb

@@ -16,11 +16,14 @@ unless defined?(DM_PLUGINS_ROOT)
 end
 
 # Require the basics...
+require 'date'
+require 'time'
 require 'rubygems'
 require 'yaml'
 require 'set'
 require 'fastthread'
 require 'validatable'
+require 'data_mapper/support/object'
 require 'data_mapper/support/blank'
 require 'data_mapper/support/enumerable'
 require 'data_mapper/support/symbol'
@@ -28,9 +31,11 @@ require 'data_mapper/support/string'
 require 'data_mapper/support/silence'
 require 'data_mapper/support/inflector'
 require 'data_mapper/support/errors'
+require 'data_mapper/support/typed_set'
 require 'data_mapper/database'
 require 'data_mapper/persistence'
 require 'data_mapper/base'
+require 'data_mapper/types/string'
 
 
 begin
@@ -80,4 +85,4 @@ begin
   end
 rescue Exception
   warn "Could not connect to database specified by database.yml."
-end
+end

data/lib/data_mapper/adapters/abstract_adapter.rb

@@ -37,63 +37,6 @@ module DataMapper
         @logger || @logger = @configuration.logger
       end
       
-      protected
-      
-      def materialize(database_context, klass, values, reload, loaded_set)
-        
-        table = self.table(klass)
-        
-        instance_id = table.key.type_cast_value(values[table.key.name])
-        
-        instance_type = if table.multi_class? && table.type_column
-          values[table.type_column.name].blank? ? klass :
-            table.type_column.type_cast_value(values[table.type_column.name])
-        else
-          klass
-        end
-        
-        instance = create_instance(database_context, instance_type, instance_id, reload)
-        
-        instance_type.callbacks.execute(:before_materialize, instance)
-        
-        type_casted_values = {}
-        
-        values.each_pair do |k,v|
-          column = table[k]
-          type_cast_value = column.type_cast_value(v)
-          type_casted_values[k] = type_cast_value
-          instance.instance_variable_set(column.instance_variable_name, type_cast_value)
-        end
-        
-        instance.original_values = type_casted_values
-        instance.loaded_set = loaded_set
-
-        instance_type.callbacks.execute(:after_materialize, instance)
-
-        return instance
-        
-      #rescue => e
-      #  raise MaterializationError.new("Failed to materialize row: #{values.inspect}\n#{e.to_yaml}")
-      end
-      
-      def create_instance(database_context, instance_type, instance_id, reload)
-        instance = database_context.identity_map.get(instance_type, instance_id)
-
-        if instance.nil? || reload
-          instance = instance_type.new() if instance.nil?
-          instance.instance_variable_set(:@__key, instance_id)
-          instance.instance_variable_set(:@new_record, false)
-          database_context.identity_map.set(instance)
-        elsif instance.new_record?
-          instance.instance_variable_set(:@__key, instance_id)
-          instance.instance_variable_set(:@new_record, false)
-        end
-
-        instance.database_context = database_context
-
-        return instance
-      end
-      
     end # class AbstractAdapter
     
   end # module Adapters

data/lib/data_mapper/adapters/data_object_adapter.rb

@@ -4,12 +4,13 @@ require 'data_mapper/adapters/sql/coersion'
 require 'data_mapper/adapters/sql/quoting'
 require 'data_mapper/adapters/sql/mappings/schema'
 require 'data_mapper/support/connection_pool'
+require 'data_mapper/query'
 
 module DataMapper
-  
+
   # An Adapter is really a Factory for three types of object,
   # so they can be selectively sub-classed where needed.
-  # 
+  #
   # The first type is a Query. The Query is an object describing
   # the database-specific operations we wish to perform, in an
   # abstract manner. For example: While most if not all databases
@@ -29,7 +30,7 @@ module DataMapper
   # If the library being adapted does not provide such functionality,
   # DataMapper::Support::ConnectionPool can be used.
   module Adapters
-      
+
     # You must inherit from the DoAdapter, and implement the
     # required methods to adapt a database library for use with the DataMapper.
     #
@@ -37,38 +38,42 @@ module DataMapper
     # standard sub-modules (Quoting, Coersion and Queries) in your own Adapter.
     # You can extend and overwrite these copies without affecting the originals.
     class DataObjectAdapter < AbstractAdapter
-      
+
       $LOAD_PATH << (DM_PLUGINS_ROOT + '/dataobjects')
-      
+
       FIND_OPTIONS = [
         :select, :offset, :limit, :class, :include, :shallow_include, :reload, :conditions, :order, :intercept_load
       ]
-      
+
       TABLE_QUOTING_CHARACTER = '`'.freeze
       COLUMN_QUOTING_CHARACTER = '`'.freeze
-      
+
+      SYNTAX = {
+        :now => 'NOW()'.freeze
+      }
+
       def initialize(configuration)
         super
         @connection_pool = Support::ConnectionPool.new { create_connection }
       end
-      
+
       def activated?
         @activated
       end
-      
+
       def activate!
         @activated = true
         schema.activate!
       end
-      
+
       def create_connection
         raise NotImplementedError.new
       end
-      
+
       def batch_insertable?
         true
       end
-      
+
       # Yields an available connection. Flushes the connection-pool and reconnects
       # if the connection returns an error.
       def connection
@@ -78,48 +83,49 @@ module DataMapper
         rescue => execution_error
           # Log error on failure
           logger.error { execution_error }
-          
+
           # Close all open connections, assuming that if one
           # had an error, it's likely due to a lost connection,
           # in which case all connections are likely broken.
           flush_connections!
-          
+
           raise execution_error
         end
       end
-      
+
       # Close any open connections.
-      def flush_connections!
-        begin
-          @connection_pool.available_connections.each do |active_connection|
+      def flush_connections!          
+        @connection_pool.available_connections.each do |active_connection|
+          begin
             active_connection.close
+          rescue => close_connection_error
+            # An error on closing the connection is almost expected
+            # if the socket is broken.
+            logger.warn { close_connection_error }
           end
-        rescue => close_connection_error
-          # An error on closing the connection is almost expected
-          # if the socket is broken.
-          logger.warn { close_connection_error }
         end
-        
+
         # Reopen fresh connections.
+        @connection_pool.instance_variable_set('@created_count', 0)
         @connection_pool.available_connections.clear
       end
-      
+
       def transaction(&block)
         raise NotImplementedError.new
       end
-      
+
       def query(*args)
         db = create_connection
-        
+
         command = db.create_command(args.shift)
-        
+
         reader = command.execute_reader(*args)
         fields = reader.fields.map { |field| Inflector.underscore(field).to_sym }
         results = []
 
         if fields.size > 1
           struct = Struct.new(*fields)
-          
+
           reader.each do
             results << struct.new(*reader.current_row)
           end
@@ -136,8 +142,8 @@ module DataMapper
       ensure
         reader.close if reader
         db.close
-      end      
-      
+      end
+
       def execute(*args)
         db = create_connection
         command = db.create_command(args.shift)
@@ -148,15 +154,15 @@ module DataMapper
       ensure
         db.close
       end
-      
+
       def handle_error(error)
         raise error
       end
-      
+
       def schema
         @schema || ( @schema = self.class::Mappings::Schema.new(self, @configuration.database) )
       end
-      
+
       def column_exists_for_table?(table_name, column_name)
         connection do |db|
           table = self.table(table_name)
@@ -166,15 +172,19 @@ module DataMapper
           end
         end
       end
-            
+
       def delete(database_context, instance)
         table = self.table(instance)
-        
+
         if instance.is_a?(Class)
           table.delete_all!
         else
           callback(instance, :before_destroy)
-          
+
+          table.associations.each do |association|
+            instance.send(association.name).deactivate unless association.is_a?(::DataMapper::Associations::BelongsToAssociation)
+          end
+
           if table.paranoid?
             instance.instance_variable_set(table.paranoid_column.instance_variable_name, Time::now)
             instance.save
@@ -189,34 +199,37 @@ module DataMapper
               database_context.identity_map.delete(instance)
               callback(instance, :after_destroy)
             end
-          end        
+          end
         end
       end
-      
-      def save(database_context, instance, validate = true)
+
+      def save(database_context, instance, validate = true, cleared = Set.new)
         case instance
-        when Class then table(instance).create!
+        when Class then
+          table(instance).create!
+          table(instance).activate_associations!
         when Mappings::Table then instance.create!
-        when DataMapper::Persistence then          
+        when DataMapper::Persistence then
           event = instance.new_record? ? :create : :update
-          
-          return false if validate && !instance.validate_recursively(event, Set.new)
-          
+
+          return false if (validate && !instance.validate_recursively(event, Set.new)) || cleared.include?(instance)
+          cleared << instance
+
           callback(instance, :before_save)
-          
-          return false unless instance.new_record? || instance.dirty?
-          
+
+          return true unless instance.new_record? || instance.dirty?
+
           result = send(event, database_context, instance)
-          
+
           instance.database_context = database_context
           instance.attributes.each_pair do |name, value|
             instance.original_values[name] = value
           end
-          
+
           instance.loaded_associations.each do |association|
-            association.save_without_validation(database_context) if association.dirty?
+            association.save_without_validation(database_context, cleared) if association.dirty?
           end
-          
+
           callback(instance, :after_save)
           result
         end
@@ -224,41 +237,56 @@ module DataMapper
         logger.error(error)
         raise error
       end
-      
-      def save_without_validation(database_context, instance)
-        save(database_context, instance, false)
+
+      def save_without_validation(database_context, instance, cleared = Set.new)
+        save(database_context, instance, false, cleared)
       end
-      
+
       def update(database_context, instance)
         callback(instance, :before_update)
-        
+
+        instance = update_magic_properties(database_context, instance)
+
         table = self.table(instance)
         attributes = instance.dirty_attributes
         parameters = []
-        
+
         unless attributes.empty?
           sql = "UPDATE " << table.to_sql << " SET "
-  
+
           sql << attributes.map do |key, value|
             parameters << value
             "#{table[key].to_sql} = ?"
           end.join(', ')
-  
+
           sql << " WHERE #{table.key.to_sql} = ?"
           parameters << instance.key
-          
-          connection do |db|
-            db.create_command(sql).execute_non_query(*parameters).to_i > 0 \
-            && callback(instance, :after_update)
+
+          result = connection do |db|
+            db.create_command(sql).execute_non_query(*parameters)
+          end
+
+          # BUG: do_mysql returns inaccurate affected row counts for UPDATE statements.
+          if true || result.to_i > 0
+            callback(instance, :after_update)
+            return true
+          else
+            return false
           end
         else
           true
         end
       end
-      
+
+      def empty_insert_sql
+        "DEFAULT VALUES"
+      end
+
       def create(database_context, instance)
         callback(instance, :before_create)
 
+        instance = update_magic_properties(database_context, instance)
+
         table = self.table(instance)
         attributes = instance.dirty_attributes
 
@@ -268,10 +296,12 @@ module DataMapper
             attributes[:type] = instance.class.name
           )
         end
-      
+
         keys = []
         values = []
         attributes.each_pair do |key, value|
+          raise ArgumentError.new("#{value.inspect} is not a valid value for #{key.inspect}") if value.is_a?(Array)
+
           keys << table[key].to_sql
           values << value
         end
@@ -279,37 +309,112 @@ module DataMapper
         sql = if keys.size > 0
           "INSERT INTO #{table.to_sql} (#{keys.join(', ')}) VALUES ?"
         else
-          "INSERT INTO #{table.to_sql}"
+          "INSERT INTO #{table.to_sql} #{self.empty_insert_sql}"
+        end
+
+        result = connection do |db|
+          db.create_command(sql).execute_non_query(values)
+        end
+
+        if result.to_i > 0
+          instance.instance_variable_set(:@new_record, false)
+          instance.key = result.last_insert_row if table.key.serial? && !attributes.include?(table.key.name)
+          database_context.identity_map.set(instance)
+          callback(instance, :after_create)
+          return true
+        else
+          return false
         end
-        
-        insert_id = connection do |db|
-          db.create_command(sql).execute_non_query(values).last_insert_row
+      end
+
+      MAGIC_PROPERTIES = {
+        :updated_at => lambda { self.updated_at = Time::now },
+        :updated_on => lambda { self.updated_on = Date::today },
+        :created_at => lambda { self.created_at ||= Time::now },
+        :created_on => lambda { self.created_on ||= Date::today }
+      }
+
+      def update_magic_properties(database_context, instance)
+        instance.class.properties.find_all { |property| MAGIC_PROPERTIES.has_key?(property.name) }.each do |property|
+          instance.instance_eval(&MAGIC_PROPERTIES[property.name])
         end
-        instance.instance_variable_set(:@new_record, false)
-        instance.key = insert_id if table.key.serial? && !attributes.include?(table.key.name)
-        database_context.identity_map.set(instance)
-        callback(instance, :after_create)
+        instance
       end
-      
+
       def load(database_context, klass, options)
         self.class::Commands::LoadCommand.new(self, database_context, klass, options).call
       end
-      
+
       def get(database_context, klass, keys)
         table = self.table(klass)
-        sql = "SELECT #{table.columns.map { |column| column.to_sql }.join(', ')} FROM #{table.to_sql} WHERE #{table.keys.map { |key| "#{key.to_sql} = ?" }.join(' AND ')}"
-        
+        instance_id = table.key.type_cast_value(keys.first)
+        instance = database_context.identity_map.get(klass, instance_id)
+
+        return instance if instance
+
+        column_indexes = {}
+        select_columns = []
+
+        table.columns.each_with_index do |column, i|
+          column_indexes[column] = i
+          select_columns << column.to_sql
+        end
+
+        sql = "SELECT #{select_columns.join(', ')} FROM #{table.to_sql} WHERE #{table.keys.map { |key| "#{key.to_sql} = ?" }.join(' AND ')}"
+
         connection do |db|
-          db.create_command(sql).execute_reader(*keys) do |reader|
-            values = {}
-            table.columns.each_with_index do |column, i|
-              values[column.name] = reader.item(i)
-            end
-            materialize(database_context, klass, values, false, [])
+          reader = nil
+          begin
+            reader = db.create_command(sql).execute_reader(*keys)
+
+            if reader.has_rows?
+
+              instance_type = klass
+
+              if table.multi_class? && table.type_column
+                value = reader.item(column_indexes[table.type_column])
+                instance_type = table.type_column.type_cast_value(value) unless value.blank?
+              end
+
+              if instance.nil?
+                instance = instance_type.allocate()
+                instance.instance_variable_set(:@__key, instance_id)
+                instance.instance_variable_set(:@new_record, false)
+                database_context.identity_map.set(instance)
+              elsif instance.new_record?
+                instance.instance_variable_set(:@__key, instance_id)
+                instance.instance_variable_set(:@new_record, false)
+                database_context.identity_map.set(instance)
+              end
+
+              instance.database_context = database_context
+
+              instance_type.callbacks.execute(:before_materialize, instance)
+
+              originals = instance.original_values
+
+              column_indexes.each_pair do |column, i|
+                value = column.type_cast_value(reader.item(i))
+                instance.instance_variable_set(column.instance_variable_name, value)
+
+                case value
+                  when String, Date, Time then originals[column.name] = value.dup
+                  else originals[column.name] = value
+                end
+              end
+
+              instance.loaded_set = [instance]
+
+              instance_type.callbacks.execute(:after_materialize, instance)
+            end # if reader.has_rows?
+          ensure
+            reader.close if reader && reader.open?
           end
-        end
+        end # connection
+
+        return instance
       end
-      
+
       def table(instance)
         case instance
         when DataMapper::Adapters::Sql::Mappings::Table then instance
@@ -318,39 +423,40 @@ module DataMapper
         else raise "Don't know how to map #{instance.inspect} to a table."
         end
       end
-      
+
       def callback(instance, callback_name)
         instance.class.callbacks.execute(callback_name, instance)
       end
-      
+
       # This callback copies and sub-classes modules and classes
       # in the DoAdapter to the inherited class so you don't
       # have to copy and paste large blocks of code from the
       # DoAdapter.
-      # 
+      #
       # Basically, when inheriting from the DoAdapter, you
       # aren't just inheriting a single class, you're inheriting
       # a whole graph of Types. For convenience.
       def self.inherited(base)
-        
+
         commands = base.const_set('Commands', Module.new)
 
         Sql::Commands.constants.each do |name|
           commands.const_set(name, Class.new(Sql::Commands.const_get(name)))
         end
-        
+
         mappings = base.const_set('Mappings', Module.new)
-        
+
         Sql::Mappings.constants.each do |name|
           mappings.const_set(name, Class.new(Sql::Mappings.const_get(name)))
         end
-        
+
         base.const_set('TYPES', TYPES.dup)
         base.const_set('FIND_OPTIONS', FIND_OPTIONS.dup)
-        
+        base.const_set('SYNTAX', SYNTAX.dup)
+
         super
       end
-      
+
       TYPES = {
         :integer => 'int'.freeze,
         :string => 'varchar'.freeze,
@@ -367,8 +473,8 @@ module DataMapper
       include Sql
       include Quoting
       include Coersion
-      
+
     end # class DoAdapter
-    
+
   end # module Adapters
-end # module DataMapper
+end # module DataMapper