activerecord 1.7.0 → 1.8.0

data/CHANGELOG

@@ -1,3 +1,58 @@
+*1.8.0* (7th March, 2005)
+
+* Added ActiveRecord::Base.colorize_logging to control whether to use colors in logs or not (on by default)
+
+* Added support for timestamp with time zone in PostgreSQL #560 [Scott Barron]
+
+* Added MultiparameterAssignmentErrors and AttributeAssignmentError exceptions #777 [demetrius]. Documentation:
+
+   * +MultiparameterAssignmentErrors+ -- collection of errors that occurred during a mass assignment using the 
+     +attributes=+ method. The +errors+ property of this exception contains an array of +AttributeAssignmentError+ 
+     objects that should be inspected to determine which attributes triggered the errors.
+   * +AttributeAssignmentError+ -- an error occurred while doing a mass assignment through the +attributes=+ method.
+     You can inspect the +attribute+ property of the exception object to determine which attribute triggered the error.
+
+* Fixed that postgresql adapter would fails when reading bytea fields with null value #771 [rodrigo k]
+
+* Added transactional fixtures that uses rollback to undo changes to fixtures instead of DELETE/INSERT -- it's much faster. See documentation under Fixtures #760 [bitsweat]
+
+* Added destruction of dependent objects in has_one associations when a new assignment happens #742 [mindel]. Example:
+
+    class Account < ActiveRecord::Base
+      has_one :credit_card, :dependent => true
+    end
+    class CreditCard < ActiveRecord::Base
+      belongs_to :account
+    end
+
+    account.credit_card # => returns existing credit card, lets say id = 12
+    account.credit_card = CreditCard.create("number" => "123")
+    account.save # => CC with id = 12 is destroyed
+
+
+* Added validates_numericality_of #716 [skanthak/c.r.mcgrath]. Docuemntation:
+
+    Validates whether the value of the specified attribute is numeric by trying to convert it to
+    a float with Kernel.Float (if <tt>integer</tt> is false) or applying it to the regular expression
+    <tt>/^[\+\-]?\d+$/</tt> (if <tt>integer</tt> is set to true).
+    
+      class Person < ActiveRecord::Base
+        validates_numericality_of :value, :on => :create
+      end
+    
+    Configuration options:
+    * <tt>message</tt> - A custom error message (default is: "is not a number")
+    * <tt>on</tt> Specifies when this validation is active (default is :save, other options :create, :update)
+    * <tt>only_integer</tt> Specifies whether the value has to be an integer, e.g. an integral value (default is false)
+    
+
+* Fixed that HasManyAssociation#count was using :finder_sql rather than :counter_sql if it was available #445 [Scott Barron]
+
+* Added better defaults for composed_of, so statements like composed_of :time_zone, :mapping => %w( time_zone time_zone ) can be written without the mapping part (it's now assumed)
+
+* Added MacroReflection#macro which will return a symbol describing the macro used (like :composed_of or :has_many) #718, #248 [james@slashetc.com]
+
+
 *1.7.0* (24th February, 2005)
 
 * Changed the auto-timestamping feature to use ActiveRecord::Base.default_timezone instead of entertaining the parallel ActiveRecord::Base.timestamps_gmt method. The latter is now deprecated and will throw a warning on use (but still work) #710 [Jamis Buck]

data/lib/active_record.rb

@@ -23,16 +23,13 @@
 
 
 $:.unshift(File.dirname(__FILE__))
+$:.unshift(File.dirname(__FILE__) + "/../../activesupport/lib")
 
 begin
-  require 'active_support'
+  require 'active_support'  
 rescue LoadError
-  begin
-    require File.dirname(__FILE__) + '/../../activesupport/lib/active_support'
-  rescue LoadError
-    require 'rubygems'
-    require_gem 'activesupport'
-  end
+  require 'rubygems'
+  require_gem 'activesupport'
 end
 
 require 'active_record/base'
@@ -47,6 +44,7 @@ require 'active_record/timestamp'
 require 'active_record/acts/list'
 require 'active_record/acts/tree'
 require 'active_record/locking'
+require 'active_record/migration'
 
 ActiveRecord::Base.class_eval do
   include ActiveRecord::Validations

data/lib/active_record/aggregations.rb

@@ -118,12 +118,13 @@ module ActiveRecord
       #   composed_of :temperature, :mapping => %w(reading celsius)
       #   composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
       #   composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
+      #   composed_of :gps_location
       def composed_of(part_id, options = {})
         validate_options([ :class_name, :mapping ], options.keys)
 
         name        = part_id.id2name
         class_name  = options[:class_name] || name_to_class_name(name)
-        mapping     = options[:mapping]
+        mapping     = options[:mapping] || [ name, name ]
 
         reader_method(name, class_name, mapping)
         writer_method(name, class_name, mapping)

data/lib/active_record/associations.rb

@@ -270,7 +270,8 @@ module ActiveRecord
       #   sql fragment, such as "rank = 5".
       # * <tt>:order</tt>       - specify the order from which the associated object will be picked at the top. Specified as
       #    an "ORDER BY" sql fragment, such as "last_name, first_name DESC"
-      # * <tt>:dependent</tt>   - if set to true the associated object is destroyed alongside this object
+      # * <tt>:dependent</tt>   - if set to true, the associated object is destroyed when this object is. It's also destroyed if another
+      #   association is assigned.
       # * <tt>:foreign_key</tt> - specify the foreign key used for the association. By default this is guessed to be the name
       #   of this class in lower-case and "_id" suffixed. So a +Person+ class that makes a has_one association will use "person_id"
       #   as the default foreign_key.

data/lib/active_record/associations/association_proxy.rb

@@ -34,6 +34,10 @@ module ActiveRecord
       end
 
       protected
+        def dependent?
+          @options[:dependent] || false
+        end
+        
         def quoted_record_ids(records)
           records.map { |record| record.quoted_id }.join(',')
         end

data/lib/active_record/associations/has_many_association.rb

@@ -24,8 +24,8 @@ module ActiveRecord
         if @options[:finder_sql]
           records = @association_class.find_by_sql(@finder_sql)
         else
-          sql = @finder_sql.dup
-          sql << " AND #{sanitize_sql(runtime_conditions)}" if runtime_conditions
+          sql = @finder_sql
+          sql += " AND #{sanitize_sql(runtime_conditions)}" if runtime_conditions
           orderings ||= @options[:order]
           records = @association_class.find_all(sql, orderings, limit, joins)
         end
@@ -33,11 +33,13 @@ module ActiveRecord
 
       # Count the number of associated records. All arguments are optional.
       def count(runtime_conditions = nil)
-        if @options[:finder_sql]
+        if @options[:counter_sql]
+          @association_class.count_by_sql(@counter_sql)
+        elsif @options[:finder_sql]
           @association_class.count_by_sql(@finder_sql)
         else
           sql = @finder_sql
-          sql << " AND #{sanitize_sql(runtime_conditions)}" if runtime_conditions
+          sql += " AND #{sanitize_sql(runtime_conditions)}" if runtime_conditions
           @association_class.count(sql)
         end
       end

data/lib/active_record/associations/has_one_association.rb

@@ -10,8 +10,13 @@ module ActiveRecord
       def replace(obj, dont_save = false)
         load_target
         unless @target.nil?
-          @target[@association_class_primary_key_name] = nil
-          @target.save unless @owner.new_record?
+          if dependent? && !dont_save     
+            @target.destroy unless @target.new_record?
+            @owner.clear_association_cache
+          else
+            @target[@association_class_primary_key_name] = nil
+            @target.save unless @owner.new_record?
+          end
         end
 
         if obj.nil?

data/lib/active_record/base.rb

@@ -1,6 +1,3 @@
-require 'active_support/class_attribute_accessors'
-require 'active_support/class_inheritable_attributes'
-require 'active_support/inflector'
 require 'yaml'
 
 module ActiveRecord #:nodoc:
@@ -29,6 +26,22 @@ module ActiveRecord #:nodoc:
   class StaleObjectError < ActiveRecordError #:nodoc:
   end
 
+  class AttributeAssignmentError < ActiveRecordError #:nodoc:
+    attr_reader :exception, :attribute
+    def initialize(message, exception, attribute)
+      @exception = exception
+      @attribute = attribute
+      @message = message
+    end
+  end
+  
+  class MultiparameterAssignmentErrors < ActiveRecordError #:nodoc:
+    attr_reader :errors
+    def initialize(errors)
+      @errors = errors
+    end
+  end
+  
   # Active Record objects doesn't specify their attributes directly, but rather infer them from the table definition with
   # which they're linked. Adding, removing, and changing attributes and their type is done directly in the database. Any change
   # is instantly reflected in the Active Record objects. The mapping that binds a given Active Record class to a certain
@@ -187,7 +200,11 @@ module ActiveRecord #:nodoc:
   #   Either the row with the given ID doesn't exist or the row didn't meet the additional restrictions.
   # * +StatementInvalid+ -- the database server rejected the SQL statement. The precise error is added in the  message.
   #   Either the record with the given ID doesn't exist or the record didn't meet the additional restrictions.
-  # 
+  # * +MultiparameterAssignmentErrors+ -- collection of errors that occurred during a mass assignment using the 
+  #   +attributes=+ method. The +errors+ property of this exception contains an array of +AttributeAssignmentError+ 
+  #   objects that should be inspected to determine which attributes triggered the errors.
+  # * +AttributeAssignmentError+ -- an error occurred while doing a mass assignment through the +attributes=+ method.
+  #   You can inspect the +attribute+ property of the exception object to determine which attribute triggered the error.
   # *Note*: The attributes listed are class-level attributes (accessible from both the class and instance level). 
   # So it's possible to assign a logger to the class through Base.logger= which will then be used by all
   # instances in the current object space.
@@ -247,6 +264,12 @@ module ActiveRecord #:nodoc:
     cattr_accessor :pluralize_table_names
     @@pluralize_table_names = true
 
+    # Determines whether or not to use ANSI codes to colorize the logging statements committed by the connection adapter. These colors
+    # makes it much easier to overview things during debugging (when used through a reader like +tail+ and on a black background), but
+    # may complicate matters if you use software like syslog. This is true, by default.
+    cattr_accessor :colorize_logging
+    @@colorize_logging = true
+
     # Determines whether to use Time.local (using :local) or Time.utc (using :utc) when pulling dates and times from the database.
     # This is set to :local by default.
     cattr_accessor :default_timezone
@@ -1254,14 +1277,22 @@ module ActiveRecord #:nodoc:
       
       # Includes an ugly hack for Time.local instead of Time.new because the latter is reserved by Time itself.
       def execute_callstack_for_multiparameter_attributes(callstack)
+        errors = []
         callstack.each do |name, values|
           klass = (self.class.reflect_on_aggregation(name) || column_for_attribute(name)).klass
           if values.empty?
             send(name + "=", nil)
           else
-            send(name + "=", Time == klass ? klass.local(*values) : klass.new(*values))
+            begin
+              send(name + "=", Time == klass ? klass.local(*values) : klass.new(*values))
+            rescue => ex
+              errors << AttributeAssignmentError.new("error on assignment #{values.inspect} to #{name}", ex, name)
+            end
           end
         end
+        unless errors.empty?
+          raise MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes"
+        end
       end
       
       def extract_callstack_for_multiparameter_attributes(pairs)

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -356,6 +356,38 @@ module ActiveRecord
         sql << " LIMIT #{limit}"
       end
 
+
+      def initialize_schema_information
+        begin
+          execute "CREATE TABLE schema_info (version #{native_database_types[:integer]})"
+          insert "INSERT INTO schema_info (version) VALUES(0)"
+        rescue ActiveRecord::StatementInvalid
+          # Schema has been intialized
+        end
+      end
+
+      def create_table(name)
+        execute "CREATE TABLE #{name} (id #{native_database_types[:primary_key]})"
+        table_definition = yield TableDefinition.new
+        table_definition.columns.each { |column_name, type, options| add_column(name, column_name, type, options) }
+      end
+
+      def drop_table(name)
+        execute "DROP TABLE #{name}"
+      end
+
+      def add_column(table_name, column_name, type, options = {})
+        add_column_sql = "ALTER TABLE #{table_name} ADD #{column_name} #{native_database_types[type]}"
+        add_column_sql << "(#{limit})" if options[:limit]
+        add_column_sql << " DEFAULT '#{options[:default]}'" if options[:default]
+        execute(add_column_sql)
+      end
+
+      def remove_column(table_name, column_name)
+        execute "ALTER TABLE #{table_name} DROP #{column_name}"
+      end
+
+
       protected
         def log(sql, name, connection = nil)
           connection ||= @connection
@@ -390,18 +422,34 @@ module ActiveRecord
         end
 
         def format_log_entry(message, dump = nil)
-          if @@row_even then
-            @@row_even = false; caller_color = "1;32"; message_color = "4;33"; dump_color = "1;37"
+          if ActiveRecord::Base.colorize_logging
+            if @@row_even then
+              @@row_even = false; caller_color = "1;32"; message_color = "4;33"; dump_color = "1;37"
+            else
+              @@row_even = true; caller_color = "1;36"; message_color = "4;35"; dump_color = "0;37"
+            end
+          
+            log_entry = "  \e[#{message_color}m#{message}\e[m"
+            log_entry << "   \e[#{dump_color}m%s\e[m" % dump if dump.kind_of?(String) && !dump.nil?
+            log_entry << "   \e[#{dump_color}m%p\e[m" % dump if !dump.kind_of?(String) && !dump.nil?
+            log_entry
           else
-            @@row_even = true; caller_color = "1;36"; message_color = "4;35"; dump_color = "0;37"
+            "%s  %s" % [message, dump]
           end
-          
-          log_entry = "  \e[#{message_color}m#{message}\e[m"
-          log_entry << "   \e[#{dump_color}m%s\e[m" % dump if dump.kind_of?(String) && !dump.nil?
-          log_entry << "   \e[#{dump_color}m%p\e[m" % dump if !dump.kind_of?(String) && !dump.nil?
-          log_entry
         end
     end
-    
+
+    class TableDefinition
+      attr_accessor :columns
+      
+      def initialize
+        @columns = []
+      end
+
+      def column(name, type, options = {})
+        @columns << [ name, type, options ]
+        self
+      end
+    end
   end
-end
+end

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -63,12 +63,33 @@ module ActiveRecord
         "Lost connection to MySQL server during query", 
         "MySQL server has gone away"
       ]
-      
+
+      def native_database_types
+        {
+          :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
+          :string      => "varchar(255)",
+          :text        => "text",
+          :integer     => "int(11)",
+          :float       => "float",
+          :datetime    => "datetime",
+          :timestamp   => "datetime",
+          :time        => "datetime",
+          :date        => "date",
+          :binary      => "blob",
+          :boolean     => "tinyint(1)"
+        }
+      end
+
       def initialize(connection, logger, connection_options=nil)
         super(connection, logger)
         @connection_options = connection_options
       end
  
+      def adapter_name
+        'MySQL'
+      end
+
+
       def select_all(sql, name = nil)
         select(sql, name)
       end
@@ -111,6 +132,7 @@ module ActiveRecord
  
       alias_method :delete, :update
  
+ 
       def begin_db_transaction
         begin
           execute "BEGIN"
@@ -134,15 +156,17 @@ module ActiveRecord
           # Transactions aren't supported
         end
       end
+
  
       def quote_column_name(name)
         return "`#{name}`"
       end
  
-      def adapter_name()
-        'MySQL'
+      def quote_string(s)
+        Mysql::quote(s)
       end
- 
+
+
       def structure_dump
         select_all("SHOW TABLES").inject("") do |structure, table|
           structure += select_one("SHOW CREATE TABLE #{table.to_a.first.last}")["Create Table"] + ";\n\n"
@@ -161,11 +185,8 @@ module ActiveRecord
       def create_database(name)
         execute "CREATE DATABASE #{name}"
       end
- 
-      def quote_string(s)
-        Mysql::quote(s)
-      end
- 
+
+
       private
         def select(sql, name = nil)
           result = nil

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -143,11 +143,11 @@ module ActiveRecord
         end
 
         def escape_bytea(s)
-          s.gsub(/\\/) { '\\\\\\\\' }.gsub(/[^\\]/) { |c| sprintf('\\\\%03o', c[0].to_i) }
+          s.gsub(/\\/) { '\\\\\\\\' }.gsub(/[^\\]/) { |c| sprintf('\\\\%03o', c[0].to_i) } unless s.nil?
         end
 
         def unescape_bytea(s)
-          s.gsub(/\\([0-9][0-9][0-9])/) { $1.oct.chr }.gsub(/\\\\/) { '\\' }
+          s.gsub(/\\([0-9][0-9][0-9])/) { $1.oct.chr }.gsub(/\\\\/) { '\\' } unless s.nil?
         end
 
         def split_table_schema(table_name)
@@ -188,6 +188,7 @@ module ActiveRecord
             when 'numeric', 'real', 'money'      then 'float'
             when 'character varying', 'interval' then 'string'
             when 'timestamp without time zone'   then 'datetime'
+            when 'timestamp with time zone'      then 'datetime'
             when 'bytea'                         then 'binary'
             else field_type
           end

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -87,6 +87,22 @@ module ActiveRecord
     #
     # * <tt>:dbfile</tt> -- Path to the database file.
     class SQLiteAdapter < AbstractAdapter
+      def native_database_types
+        {
+          :primary_key => "INTEGER PRIMARY KEY NOT NULL",
+          :string      => "VARCHAR(255)",
+          :text        => "TEXT",
+          :integer     => "INTEGER",
+          :float       => "float",
+          :datetime    => "DATETIME",
+          :timestamp   => "DATETIME",
+          :time        => "DATETIME",
+          :date        => "DATE",
+          :binary      => "BLOB",
+          :boolean     => "INTEGER"
+        }
+      end
+
       def execute(sql, name = nil)
         log(sql, name) { @connection.execute(sql) }
       end
@@ -150,6 +166,7 @@ module ActiveRecord
         'SQLite'
       end
 
+
       protected
         def table_structure(table_name)
           execute "PRAGMA table_info(#{table_name})"