datamapper 0.2.0 → 0.2.1

data/CHANGELOG

@@ -94,4 +94,23 @@
 * Removed TableExistsCommand
 * Session renamed to Context
 * Most command implementations moved to methods in SqlAdapter
-* Removed UnitOfWork module, instead moving a slightly refactored implementation into Base
+* Removed UnitOfWork module, instead moving a slightly refactored implementation into Base
+
+-- 0.2.1
+* Added :float column support
+* Added association proxies: ie: Zoo.first.exhibits.animals
+* Columns stored in SortedSet
+* Swig files are no longer RDOCed
+* Added :date column support
+* BUG: Fixed UTC issues with datetimes
+* Added #to_yaml method
+* Added #to_xml method
+* Added #to_json method
+* BUG: Fixed HasManyAssociation::Set#inspect
+* BUG: Fixed #reload!
+* BUG: Column copy for STI moved into Table#initialize to better handle STI with multiple mapped databases
+* BUG: before_create callbacks moved in the execution flow since they weren't guaranteed to fire before
+* Threading enhancements: Removed single_threaded_mode, #database block form adjusted for thread-safety
+* BUG: Fixed String#blank? when a multi-line string contained a blank line (thanks pimpmaster!)
+* Performance enhancements: (thanks wycats!)
+

data/environment.rb

@@ -1,3 +1,6 @@
+MERB_ROOT = Dir::pwd
+MERB_ENV = 'development'
+
 # Require the DataMapper, and a Mock Adapter.
 require File.dirname(__FILE__) + '/lib/data_mapper'
 require File.dirname(__FILE__) + '/spec/mock_adapter'
@@ -6,8 +9,7 @@ adapter = ENV['ADAPTER'] || 'sqlite3'
 
 configuration_options = {
   :adapter => adapter,
-  :database =>  (ENV['DATABASE'] || 'data_mapper_1').dup,
-  :single_threaded => true
+  :database =>  (ENV['DATABASE'] || 'data_mapper_1').dup
 }
 
 # Prepare the log path, and remove the existing spec.log
@@ -42,4 +44,4 @@ DataMapper::Database.setup(:mock, :adapter => MockAdapter)
 [:default, :mock].each { |name| database(name) { load_models.call } }
 
 # Reset the test database.
-DataMapper::Base.auto_migrate! 
+DataMapper::Base.auto_migrate! unless ENV['AUTO_MIGRATE'] == 'false'

data/lib/data_mapper.rb

@@ -9,10 +9,11 @@
 
 # This line just let's us require anything in the +lib+ sub-folder
 # without specifying a full path.
+unless defined?(DM_PLUGINS_ROOT)
+  $LOAD_PATH.unshift(File.dirname(__FILE__))
 
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-DM_PLUGINS_ROOT = (File.dirname(__FILE__) + '/../plugins')
+  DM_PLUGINS_ROOT = (File.dirname(__FILE__) + '/../plugins')
+end
 
 # Require the basics...
 require 'yaml'
@@ -29,27 +30,45 @@ require 'data_mapper/base'
 # This block of code is for compatibility with Ruby On Rails' or Merb's database.yml
 # file, allowing you to simply require the data_mapper.rb in your
 # Rails application's environment.rb to configure the DataMapper.
-
-application_root, application_environment = *if defined?(MERB_ROOT)
-  [MERB_ROOT, MERB_ENV]
-elsif defined?(RAILS_ROOT)
-  [RAILS_ROOT, RAILS_ENV]
-end
-
-DM_APP_ROOT = application_root || Dir::pwd
-
-if application_root && File.exists?(application_root + '/config/database.yml')
+unless defined?(DM_APP_ROOT)
+  application_root, application_environment = *if defined?(MERB_ROOT)
+    [MERB_ROOT, MERB_ENV]
+  elsif defined?(RAILS_ROOT)
+    [RAILS_ROOT, RAILS_ENV]
+  end
   
-  database_configurations = YAML::load_file(application_root + '/config/database.yml')
-  current_database_config = database_configurations[application_environment] || database_configurations[application_environment.to_sym]
+  DM_APP_ROOT = application_root || Dir::pwd
   
-  default_database_config = {
-    :adapter  => current_database_config['adapter'] || current_database_config[:adapter],
-    :host     => current_database_config['host'] || current_database_config[:host],
-    :database => current_database_config['database'] || current_database_config[:database],
-    :username => current_database_config['username'] || current_database_config[:username],
-    :password => current_database_config['password'] || current_database_config[:password]
-  }
+  if application_root && File.exists?(application_root + '/config/database.yml')
+
+    database_configurations = YAML::load_file(application_root + '/config/database.yml')
+    current_database_config = database_configurations[application_environment] || database_configurations[application_environment.to_sym]
+    
+    config = lambda { |key| current_database_config[key.to_s] || current_database_config[key] }
+    
+    default_database_config = {
+      :adapter  => config[:adapter],
+      :host     => config[:host],
+      :database => config[:database],
+      :username => config[:username],
+      :password => config[:password]
+    }
   
-  DataMapper::Database.setup(default_database_config)
+    DataMapper::Database.setup(default_database_config)
+    
+  elsif application_root && FileTest.directory?(application_root + '/config')
+    
+    %w(development testing production).map do |environment|
+      <<-EOS.margin
+        #{environment}:
+          adapter: mysql
+          username: root
+          password:
+          host: localhost
+          database: #{File.dirname(DM_APP_ROOT).split('/').last}_#{environment}
+      EOS
+    end
+    
+    #File::open(application_root + '/config/database.yml')
+  end
 end

data/lib/data_mapper/adapters/data_object_adapter.rb

@@ -49,10 +49,7 @@ module DataMapper
       
       def initialize(configuration)
         super
-
-        unless @configuration.single_threaded?
-          @connection_pool = Support::ConnectionPool.new { create_connection }
-        end
+        @connection_pool = Support::ConnectionPool.new(4) { create_connection }
       end
       
       def create_connection
@@ -64,11 +61,7 @@ module DataMapper
       def connection
         begin
           # Yield the appropriate connection
-          if @configuration.single_threaded?
-            yield(@active_connection || @active_connection = create_connection)
-          else
-            @connection_pool.hold { |active_connection| yield(active_connection) }
-          end
+          @connection_pool.hold { |active_connection| yield(active_connection) }
         rescue => execution_error
           # Log error on failure
           @configuration.log.error(execution_error)
@@ -76,31 +69,28 @@ module DataMapper
           # 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.
-          begin
-            if @configuration.single_threaded?
-              @active_connection.close
-            else
-              @connection_pool.available_connections.each do |active_connection|
-                active_connection.close
-              end
-            end
-          rescue => close_connection_error
-            # An error on closing the connection is almost expected
-            # if the socket is broken.
-            @configuration.log.warn(close_connection_error)
-          end
-          
-          # Reopen fresh connections.
-          if @configuration.single_threaded?
-            @active_connection = create_connection
-          else
-            @connection_pool.available_connections.clear
-          end
+          flush_connections!
           
           raise execution_error
         end
       end
+      
+      # Close any open connections.
+      def flush_connections!
+        begin
+          @connection_pool.available_connections.each do |active_connection|
+            active_connection.close
+          end
+        rescue => close_connection_error
+          # An error on closing the connection is almost expected
+          # if the socket is broken.
+          @configuration.log.warn(close_connection_error)
+        end
         
+        # Reopen fresh connections.
+        @connection_pool.available_connections.clear
+      end
+      
       def transaction(&block)
         raise NotImplementedError.new
       end
@@ -109,43 +99,45 @@ module DataMapper
         connection do |db|
           sql = escape_sql(*args)
           log.debug { sql }
-          result = nil
-          
+        
           command = db.create_command(sql)
-          
+        
           if block_given?
-            reader = command.execute_reader
-            result = yield(reader)
-            reader.close
+            command.execute_reader { |reader| yield(reader) }
           else
-            result = command.execute_non_query
+            command.execute_non_query
           end
-          
-          result
         end
       rescue => e
         handle_error(e)
       end
       
-      def query(*args)
-        execute(*args) do |reader|
-          fields = reader.fields.map { |field| Inflector.underscore(field).to_sym }
-
-          results = []
-          
-          if fields.size > 1
-            struct = Struct.new(*fields)
+      def query(*args)        
+        connection do |db|
+          sql = escape_sql(*args)
+          log.debug { sql }
+        
+          command = db.create_command(sql)
+        
+          command.execute_reader do |reader|
+            fields = reader.fields.map { |field| Inflector.underscore(field).to_sym }
             
-            reader.each do
-              results << struct.new(*reader.current_row)
-            end
-          else
-            reader.each do
-              results << reader.item(0)
+            results = []
+
+            if fields.size > 1
+              struct = Struct.new(*fields)
+              
+              reader.each do
+                results << struct.new(*reader.current_row)
+              end
+            else
+              reader.each do
+                results << reader.item(0)
+              end
             end
+
+            results            
           end
-          
-          results
         end
       end      
       
@@ -174,7 +166,13 @@ module DataMapper
       end
       
       def create_table(name)
-        execute(table(name).to_create_table_sql); true
+        table = self.table(name)
+        
+        if table.exists?
+          false
+        else
+          execute(table.to_create_table_sql); true
+        end
       end
       
       def delete(session, instance)
@@ -202,46 +200,51 @@ module DataMapper
         when DataMapper::Base then
           return false unless instance.dirty? && instance.valid?
           
-          callback(instance, :before_save)
-          
-          table = self.table(instance)
-          attributes = instance.dirty_attributes
+          callback(instance, :before_save)           
           
-          unless attributes.empty?
-            attributes[:type] = instance.class.name if table.multi_class?
-          
-            # INSERT
-            result = if instance.new_record?
-              callback(instance, :before_create)
+          # INSERT
+          result = if instance.new_record?
+            callback(instance, :before_create)
 
+            table = self.table(instance)
+            attributes = instance.dirty_attributes
+            
+            unless attributes.empty?
+              attributes[:type] = instance.class.name if table.multi_class?
+            
               keys = []
               values = []
               attributes.each_pair do |key, value|
                 keys << table[key].to_sql
                 values << value
               end
-            
+          
               # Formatting is a bit off here, but it looks nicer in the log this way.
               insert_id = execute("INSERT INTO #{table.to_sql} (#{keys.join(', ')}) VALUES (#{values.map { |v| quote_value(v) }.join(', ')})").last_insert_row
               instance.instance_variable_set(:@new_record, false)
               instance.key = insert_id if table.key.serial? && !attributes.include?(table.key.name)
               session.identity_map.set(instance)
               callback(instance, :after_create)
-            # UPDATE
-            else            
-              callback(instance, :before_update)
+            end
+          # UPDATE
+          else            
+            callback(instance, :before_update)
+            
+            table = self.table(instance)
+            attributes = instance.dirty_attributes
             
+            unless attributes.empty?
               sql = "UPDATE " << table.to_sql << " SET "
-        
+      
               sql << attributes.map do |key, value|
                 "#{table[key].to_sql} = #{quote_value(value)}"
               end.join(', ')
-        
+      
               sql << " WHERE #{table.key.to_sql} = " << quote_value(instance.key)
-            
+          
               execute(sql).to_i > 0 && callback(instance, :after_update)
             end
-          end # unless attributes.empty?
+          end
           
           instance.attributes.each_pair do |name, value|
             instance.original_hashes[name] = value.hash

data/lib/data_mapper/adapters/mysql_adapter.rb

@@ -1,7 +1,7 @@
 require 'data_mapper/adapters/data_object_adapter'
 begin
   require 'do_mysql'
-rescue
+rescue LoadError
   STDERR.puts <<-EOS
 You must install the DataObjects::Mysql driver.
   rake dm:install:mysql
@@ -24,6 +24,8 @@ module DataMapper
         builder['dbname', :database]
         builder['socket', :socket]
         
+        log.debug { connection_string.strip }
+        
         conn = DataObject::Mysql::Connection.new(connection_string.strip)
         conn.open
         cmd = conn.create_command("SET NAMES UTF8")
@@ -31,6 +33,18 @@ module DataMapper
         return conn
       end
       
+      def quote_time(value)
+        "DATE('#{value.xmlschema}')"
+      end
+      
+      def quote_datetime(value)
+        "DATE('#{value}')"
+      end
+      
+      def quote_date(value)
+        "DATE('#{value.strftime("%Y-%m-%d")}')"
+      end
+      
       module Mappings
         
         def to_create_table_sql

data/lib/data_mapper/adapters/postgresql_adapter.rb

@@ -1,7 +1,7 @@
 require 'data_mapper/adapters/data_object_adapter'
 begin
   require 'do_postgres'
-rescue
+rescue LoadError
   STDERR.puts <<-EOS
 You must install the DataObjects::PostgreSQL driver.
   rake dm:install:postgresql

data/lib/data_mapper/adapters/sql/commands/load_command.rb

@@ -1,26 +1,144 @@
-require 'data_mapper/adapters/sql/commands/conditions'
-require 'data_mapper/adapters/sql/commands/loader'
-
 module DataMapper
   module Adapters
     module Sql
       module Commands
     
         class LoadCommand
-      
+          
+          class Loader
+
+            def initialize(load_command, klass)
+              @load_command, @klass = load_command, klass
+              @columns = {}
+              @key = nil
+              @key_index = nil
+              @type_override_present = false
+              @type_override_index = nil
+              @type_override = nil
+              @session = load_command.session
+              @reload = load_command.reload?
+              @set = []
+            end
+
+            def add_column(column, index)
+              if column.key?
+                @key = column 
+                @key_index = index
+              end
+
+              if column.type == :class
+                @type_override_present = true
+                @type_override_index = index
+                @type_override = column
+              end
+
+              @columns[index] = column
+
+              self
+            end
+
+            def materialize(values)
+
+              instance_id = @key.type_cast_value(values[@key_index])
+              instance = if @type_override_present
+                create_instance(instance_id, @type_override.type_cast_value(values[@type_override_index]))
+              else
+                create_instance(instance_id)
+              end
+
+              @klass.callbacks.execute(:before_materialize, instance)
+
+              original_hashes = instance.original_hashes
+
+              @columns.each_pair do |index, column|
+                # This may be a little confusing, but we're
+                # setting both the original-hash value, and the
+                # instance-variable through method chaining to avoid
+                # lots of extra short-lived local variables.
+                original_hashes[column.name] = instance.instance_variable_set(
+                  column.instance_variable_name,
+                  column.type_cast_value(values[index])
+                ).hash
+              end
+
+              instance.instance_variable_set(:@loaded_set, @set)
+              @set << instance
+
+              @klass.callbacks.execute(:after_materialize, instance)
+
+              return instance
+            end
+
+            def loaded_set
+              @set
+            end
+
+            private
+
+              def create_instance(instance_id, instance_type = @klass)
+                instance = @session.identity_map.get(@klass, 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)
+                  @session.identity_map.set(instance)
+                elsif instance.new_record?
+                  instance.instance_variable_set(:@__key, instance_id)
+                  instance.instance_variable_set(:@new_record, false)
+                end
+
+                instance.session = @session
+
+                return instance
+              end
+
+          end
+          
+          class ConditionsError < StandardError
+
+            attr_reader :inner_error
+
+            def initialize(clause, value, inner_error)
+              @clause, @value, @inner_error = clause, value, inner_error
+            end
+
+            def message
+              "Conditions (:clause => #{@clause.inspect}, :value => #{@value.inspect}) failed: #{@inner_error}"
+            end
+
+            def backtrace
+              @inner_error.backtrace
+            end              
+
+          end
+          
           attr_reader :conditions, :session, :options
           
           def initialize(adapter, session, primary_class, options = {})
             @adapter, @session, @primary_class = adapter, session, primary_class
             
-            @options, conditions_hash = partition_options(options)
+            # BEGIN: Partion out the options hash into general options,
+            # and conditions.
+            standard_find_options = @adapter.class::FIND_OPTIONS
+            conditions_hash = {}
+            @options = {}
+            
+            options.each do |key,value|
+              if standard_find_options.include?(key) && key != :conditions
+                @options[key] = value
+              else
+                conditions_hash[key] = value
+              end
+            end
+            # END
             
             @order = @options[:order]
             @limit = @options[:limit]
             @offset = @options[:offset]
             @reload = @options[:reload]
             @instance_id = conditions_hash[:id]
-            @conditions = Conditions.new(@adapter, self, conditions_hash)
+            @conditions = parse_conditions(conditions_hash)
             @loaders = Hash.new { |h,k| h[k] = Loader.new(self, k) }
           end
           
@@ -75,7 +193,7 @@ module DataMapper
             unless reload? || @instance_id.blank? || @instance_id.is_a?(Array)
               # If the id is for only a single record, attempt to find it.
               if instance = @session.identity_map.get(@primary_class, @instance_id)
-                return instance
+                return [instance]
               end
             end
             
@@ -92,11 +210,7 @@ module DataMapper
             
             results += @loaders[@primary_class].loaded_set
             
-            if @limit == 1 || (@instance_id && !@instance_id.is_a?(Array))
-              results.first
-            else
-              results
-            end
+            return results
           end
           
           def load(reader)          
@@ -120,6 +234,11 @@ module DataMapper
             end
           end
           
+          # Are any conditions present?
+          def conditions_empty?
+            @conditions.empty?
+          end
+          
           # Generate a select statement based on the initialization
           # arguments.
           def to_parameterized_sql
@@ -136,10 +255,29 @@ module DataMapper
               sql << ' ' << association.to_shallow_sql
             end
             
-            unless conditions.empty?
-              where_clause, *parameters = conditions.to_parameterized_sql
-              sql << ' WHERE ' << where_clause
-            end
+            unless conditions_empty?
+              sql << ' WHERE ('
+              
+              last_index = @conditions.size
+              current_index = 0
+              
+              @conditions.each do |condition|
+                case condition
+                when String then sql << condition
+                when Array then
+                    sql << condition.shift
+                    parameters += condition
+                else
+                  raise "Unable to parse condition: #{condition.inspect}" if condition
+                end
+                
+                if (current_index += 1) == last_index
+                  sql << ')'
+                else
+                  sql << ') AND ('
+                end
+              end
+            end # unless conditions_empty?
             
             unless @order.nil?
               sql << ' ORDER BY ' << @order.to_s
@@ -156,9 +294,62 @@ module DataMapper
             parameters.unshift(sql)
           end
           
+          # If more than one table is involved in the query, the column definitions should
+          # be qualified by the table name. ie: people.name
+          # This method determines wether that needs to happen or not.
+          # Note: After the first call, the calculations are avoided by overwriting this
+          # method with a simple getter.
           def qualify_columns?
-            return @qualify_columns unless @qualify_columns.nil?
             @qualify_columns = !(included_associations.empty? && shallow_included_associations.empty?)
+            def self.qualify_columns?
+              @qualify_columns
+            end
+            @qualify_columns
+          end
+          
+          # expression_to_sql takes a set of arguments, and turns them into a an
+          # Array of generated SQL, followed by optional Values to interpolate as SQL-Parameters.
+          #
+          # Parameters:
+          # +clause+ The name of the column as a Symbol, a raw-SQL String, a Mappings::Column
+          # instance, or a Symbol::Operator.
+          # +value+ The Value for the condition.
+          # +collector+ An Array representing all conditions that is appended to by expression_to_sql
+          #
+          # Returns: Undefined Output. The work performed is added to the +collector+ argument.
+          # Example:
+          #   conditions = []
+          #   expression_to_sql(:name, 'Bob', conditions)
+          #   => +undefined return value+
+          #   conditions.inspect
+          #   => ["name = ?", 'Bob']
+          def expression_to_sql(clause, value, collector)
+            qualify_columns = qualify_columns?
+
+            case clause
+            when Symbol::Operator then
+              operator = case clause.type
+              when :gt then '>'
+              when :gte then '>='
+              when :lt then '<'
+              when :lte then '<='
+              when :not then inequality_operator(value)
+              when :eql then equality_operator(value)
+              when :like then equality_operator(value, 'LIKE')
+              when :in then equality_operator(value)
+              else raise ArgumentError.new('Operator type not supported')
+              end
+              collector << ["#{primary_class_table[clause].to_sql(qualify_columns)} #{operator} ?", value]
+            when Symbol then
+              collector << ["#{primary_class_table[clause].to_sql(qualify_columns)} #{equality_operator(value)} ?", value]
+            when String then
+              collector << [clause, value]
+            when Mappings::Column then
+              collector << ["#{clause.to_sql(qualify_columns)} #{equality_operator(value)} ?", value]
+            else raise "CAN HAS CRASH? #{clause.inspect}"
+            end
+          rescue => e
+            raise ConditionsError.new(clause, value, e)
           end
           
           private            
@@ -277,19 +468,42 @@ module DataMapper
               @primary_class_table || (@primary_class_table = @adapter.table(@primary_class))
             end
             
-            def partition_options(options)
-              find_options = @adapter.class::FIND_OPTIONS
-              conditions_hash = {}
-              options_hash = {}
-              options.each do |key,value|
-                if key != :conditions && find_options.include?(key)
-                  options_hash[key] = value
-                else
-                  conditions_hash[key] = value
+            def parse_conditions(conditions_hash)
+              collection = []
+
+              case x = conditions_hash.delete(:conditions)
+              when Array then
+                clause = x.shift
+                expression_to_sql(clause, x, collection)
+              when Hash then
+                x.each_pair do |key,value|
+                  expression_to_sql(key, value, collection)
                 end
+              else
+                raise "Unable to parse conditions: #{x.inspect}" if x
+              end
+
+              conditions_hash.each_pair do |key,value|
+                expression_to_sql(key, value, collection)
+              end
+
+              collection              
+            end
+
+            def equality_operator(value, default = '=')
+              case value
+              when NilClass then 'IS'
+              when Array then 'IN'
+              else default
+              end
+            end
+
+            def inequality_operator(value, default = '<>')
+              case value
+              when NilClass then 'IS NOT'
+              when Array then 'NOT IN'
+              else default
               end
-              
-              [ options_hash, conditions_hash ]
             end
           
         end # class LoadCommand