activerecord 1.2.0 → 1.3.0

data/CHANGELOG

@@ -1,3 +1,68 @@
+*1.3.0*
+
+* Added a require_association hook on const_missing that makes it possible to use any model class without requiring it first. This makes STI look like:
+
+    before:
+      require_association 'person'
+      class Employee < Person
+      end
+    
+    after:
+      class Employee < Person
+      end
+
+  This also reduces the usefulness of Controller.model in Action Pack to currently only being for documentation purposes.      
+
+* Added that Base.update_all and Base.delete_all return an integer of the number of affected rows #341
+
+* Added scope option to validation_uniqueness #349 [Kent Sibilev]
+
+* Added respondence to *_before_type_cast for all attributes to return their string-state before they were type casted by the column type.
+  This is helpful for getting "100,000" back on a integer-based validation where the value would normally be "100".
+
+* Added allow_nil options to validates_inclusion_of so that validation is only triggered if the attribute is not nil [what-a-day]
+
+* Added work-around for PostgreSQL and the problem of getting fixtures to be created from id 1 on each test case.
+  This only works for auto-incrementing primary keys called "id" for now #359 [Scott Baron]
+
+* Added Base#clear_association_cache to empty all the cached associations #347 [Tobias Luetke]
+
+* Added more informative exceptions in establish_connection #356 [bitsweat]
+
+* Added Base#update_attributes that'll accept a hash of attributes and save the record (returning true if it passed validation, false otherwise). 
+
+    Before:
+      person.attributes = @params["person"]
+      person.save
+    
+    Now:
+      person.update_attributes(@params["person"])
+
+* Added Base.destroy and Base.delete to remove records without holding a reference to them first.
+
+* Added that query benchmarking will only happen if its going to be logged anyway #344
+
+* Added higher_item and lower_item as public methods for acts_as_list #342 [Tobias Luetke]
+
+* Fixed that options[:counter_sql] was overwritten with interpolated sql rather than original sql #355 [bitsweat]
+
+* Fixed that overriding an attribute's accessor would be disregarded by add_on_empty and add_on_boundary_breaking because they simply used 
+  the attributes[] hash instead of checking for @base.respond_to?(attr.to_s). [Marten]
+
+* Fixed that Base.table_name would expect a parameter when used in has_and_belongs_to_many joins [Anna Lissa Cruz]
+
+* Fixed that nested transactions now work by letting the outer most transaction have the responsibilty of starting and rolling back the transaction.
+  If any of the inner transactions swallow the exception raised, though, the transaction will not be rolled back. So always let the transaction
+  bubble up even when you've dealt with local issues. Closes #231 and #340.
+
+* Fixed validates_{confirmation,acceptance}_of to only happen when the virtual attributes are not nil #348 [dpiddy@gmail.com]
+
+* Changed the interface on AbstractAdapter to require that adapters return the number of affected rows on delete and update operations.
+
+* Fixed the automated timestamping feature when running under Rails' development environment that resets the inheritable attributes on each request.
+
+
+
 *1.2.0*
 
 * Added Base.validates_inclusion_of that validates whether the value of the specified attribute is available in a particular enumerable

data/install.rb

@@ -42,8 +42,8 @@ files = %w-
  active_record/fixtures.rb
  active_record/observer.rb
  active_record/reflection.rb
- active_record/mixins/list.rb
- active_record/mixins/touch.rb
+ active_record/acts/list.rb
+ active_record/acts/tree.rb
  active_record/support/class_attribute_accessors.rb
  active_record/support/class_inheritable_attributes.rb
  active_record/support/clean_logger.rb

data/lib/active_record.rb

@@ -41,12 +41,12 @@ require 'active_record/acts/tree'
 
 ActiveRecord::Base.class_eval do
   include ActiveRecord::Validations
+  include ActiveRecord::Timestamp
   include ActiveRecord::Callbacks
   include ActiveRecord::Associations
   include ActiveRecord::Aggregations
   include ActiveRecord::Transactions
   include ActiveRecord::Reflection
-  include ActiveRecord::Timestamp
   include ActiveRecord::Acts::Tree
   include ActiveRecord::Acts::List
 end

data/lib/active_record/acts/list.rb

@@ -109,6 +109,18 @@ module ActiveRecord
         def last?
           self.send(position_column) == bottom_position_in_list
         end
+        
+        def higher_item
+          self.class.find_first(
+            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i - 1).to_s}"
+          )
+        end
+
+        def lower_item
+          self.class.find_first(
+            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i + 1).to_s}"
+          )
+        end
 
         private
         
@@ -123,18 +135,6 @@ module ActiveRecord
         # Overwrite this method to define the scope of the list changes
         def scope_condition() "1" end
 
-        def higher_item
-          self.class.find_first(
-            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i - 1).to_s}"
-          )
-        end
-
-        def lower_item
-          self.class.find_first(
-            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i + 1).to_s}"
-          )
-        end
-
         def bottom_position_in_list
           item = bottom_item
           item ? item.send(position_column) : 0
@@ -163,7 +163,7 @@ module ActiveRecord
   
         def increment_positions_on_higher_items
           self.class.update_all(
-            "#{position_column} = (#{position_column} + 1)",  "#{scope_condition} AND #{position_column} < #{send(position_column)}"
+            "#{position_column} = (#{position_column} + 1)",  "#{scope_condition} AND #{position_column} < #{send(position_column).to_i}"
           )
         end
 

data/lib/active_record/associations.rb

@@ -3,10 +3,30 @@ require 'active_record/associations/has_many_association'
 require 'active_record/associations/has_and_belongs_to_many_association'
 require 'active_record/deprecated_associations'
 
+
 unless Object.respond_to?(:require_association)
   Object.send(:define_method, :require_association) { |file_name| ActiveRecord::Base.require_association(file_name) }
 end
 
+class Object
+  class << self
+    # Use const_missing to autoload associations so we don't have to
+    # require_association when using single-table inheritance.
+    unless respond_to?(:pre_association_const_missing)
+      alias_method :pre_association_const_missing, :const_missing
+
+      def const_missing(class_id)
+        begin
+          require_association(Inflector.underscore(Inflector.demodulize(class_id.to_s)))
+          return Object.const_get(class_id) if Object.const_get(class_id).ancestors.include?(ActiveRecord::Base)
+        rescue LoadError
+          pre_association_const_missing(class_id)
+        end
+      end
+    end
+  end
+end
+
 module ActiveRecord
   module Associations # :nodoc:
     def self.append_features(base)
@@ -14,6 +34,13 @@ module ActiveRecord
       base.extend(ClassMethods)
     end
 
+    # Clears out the association cache 
+    def clear_association_cache #:nodoc:
+      self.class.reflect_on_all_associations.to_a.each do |assoc|
+        instance_variable_set "@#{assoc.name}", nil
+      end
+    end
+
     # Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like 
     # "Project has one Project Manager" or "Project belongs to a Portfolio". Each macro adds a number of methods to the class which are 
     # specialized according to the collection or association symbol and the options hash. It works much the same was as Ruby's own attr* 
@@ -464,6 +491,17 @@ module ActiveRecord
       def reset_associations_loaded
         self.associations_loaded = []
       end
+      
+      # Reload all the associations that have already been loaded once.
+      def reload_associations_loaded
+        associations_loaded.each do |file_name| 
+          begin
+            silence_warnings { load("#{file_name}.rb") }
+          rescue LoadError
+            # The association didn't reside in its own file, so we assume it was required by other means
+          end
+        end
+      end
 
       private
         # Raises an exception if an invalid option has been specified to prevent misspellings from slipping through 

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -5,7 +5,7 @@ module ActiveRecord
         super(owner, association_name, association_class_name, association_class_primary_key_name, options)
 
         @association_foreign_key = options[:association_foreign_key] || Inflector.underscore(Inflector.demodulize(association_class_name)) + "_id"
-        association_table_name = options[:table_name] || @association_class.table_name(association_class_name)
+        association_table_name = options[:table_name] || @association_class.table_name
         @join_table = join_table
         @order = options[:order] || "t.#{@association_class.primary_key}"
 

data/lib/active_record/associations/has_many_association.rb

@@ -14,7 +14,8 @@ module ActiveRecord
         if options[:counter_sql]
           @counter_sql = interpolate_sql(options[:counter_sql])
         elsif options[:finder_sql]
-          @counter_sql = options[:counter_sql] = @finder_sql.gsub(/SELECT (.*) FROM/i, "SELECT COUNT(*) FROM")
+          options[:counter_sql] = options[:finder_sql].gsub(/SELECT (.*) FROM/i, "SELECT COUNT(*) FROM")
+          @counter_sql = interpolate_sql(options[:counter_sql])
         else
           @counter_sql = "#{@association_class_primary_key_name} = #{@owner.quoted_id}#{@conditions ? " AND " + interpolate_sql(@conditions) : ""}"
         end

data/lib/active_record/base.rb

@@ -333,13 +333,23 @@ module ActiveRecord #:nodoc:
         object
       end
 
-      # Updates all records with the SET-part of an SQL update statement in +updates+. A subset of the records can be selected 
-      # by specifying +conditions+. Example:
+      # Deletes the record with the given +id+ without instantiating an object first.
+      def delete(id)
+        delete_all([ "#{primary_key} = ?", id ])
+      end
+      
+      # Destroys the record with the given +id+ by instantiating the object and calling #destroy (all the callbacks are the triggered).
+      def destroy(id)
+        find(id).destroy
+      end
+
+      # Updates all records with the SET-part of an SQL update statement in +updates+ and returns an integer with the number of rows updates.
+      # A subset of the records can be selected by specifying +conditions+. Example:
       #   Billing.update_all "category = 'authorized', approved = 1", "author = 'David'"
       def update_all(updates, conditions = nil)
         sql  = "UPDATE #{table_name} SET #{updates} "
         add_conditions!(sql, conditions)
-        connection.update(sql, "#{name} Update")
+        return connection.update(sql, "#{name} Update")
       end
     
       # Destroys the objects for all the records that matches the +condition+ by instantiating each object and calling
@@ -463,13 +473,8 @@ module ActiveRecord #:nodoc:
       #   class Mouse < ActiveRecord::Base
       #      def self.table_name() "mice" end
       #   end
-      def table_name(class_name = nil)
-        if class_name.nil?
-          class_name  = class_name_of_active_record_descendant(self)
-          table_name_prefix + undecorated_table_name(class_name) + table_name_suffix
-        else
-          table_name_prefix + undecorated_table_name(class_name) + table_name_suffix
-        end
+      def table_name
+        table_name_prefix + undecorated_table_name(class_name_of_active_record_descendant(self)) + table_name_suffix
       end
 
       # Defines the primary key field -- can be overridden in subclasses. Overwritting will negate any effect of the
@@ -522,6 +527,7 @@ module ActiveRecord #:nodoc:
           methods[attr.to_sym]       = true
           methods["#{attr}=".to_sym] = true
           methods["#{attr}?".to_sym] = true
+          methods["#{attr}_before_type_cast".to_sym] = true
           methods
         end
       end
@@ -723,6 +729,10 @@ module ActiveRecord #:nodoc:
         read_attribute(self.class.primary_key)
       end
       
+      def id_before_type_cast
+        read_attribute_before_type_cast(self.class.primary_key)
+      end
+
       def quoted_id
         quote(id, self.class.columns_hash[self.class.primary_key])
       end
@@ -777,9 +787,18 @@ module ActiveRecord #:nodoc:
       end
             
       # Updates a single attribute and saves the record. This is especially useful for boolean flags on existing records.
+      # Note: This method is overwritten by the Validation module that'll make sure that updates made with this method
+      # doesn't get subjected to validation checks. Hence, attributes can be updated even if the full object isn't valid.
       def update_attribute(name, value)
         self[name] = value
-        save
+        return true
+      end
+
+      # Updates all the attributes in from the passed hash and saves the record. If the object is invalid, the saving will
+      # fail and false will be returned.
+      def update_attributes(attributes)
+        self.attributes = attributes
+        return save
       end
 
       # Returns the value of attribute identified by <tt>attr_name</tt> after it has been type cast (for example, 
@@ -901,10 +920,10 @@ module ActiveRecord #:nodoc:
       def method_missing(method_id, *arguments)
         method_name = method_id.id2name
       
-      
-      
         if method_name =~ read_method? && @attributes.include?($1)
           return read_attribute($1)
+        elsif method_name =~ read_untyped_method? && @attributes.include?($1)
+          return read_attribute_before_type_cast($1)
         elsif method_name =~ write_method? && @attributes.include?($1)
           write_attribute($1, arguments[0])
         elsif method_name =~ query_method? && @attributes.include?($1)
@@ -914,25 +933,30 @@ module ActiveRecord #:nodoc:
         end
       end
 
-      def read_method?()  /^([a-zA-Z][-_\w]*)[^=?]*$/ end
-      def write_method?() /^([a-zA-Z][-_\w]*)=.*$/    end
-      def query_method?() /^([a-zA-Z][-_\w]*)\?$/     end
+      def read_method?()         /^([a-zA-Z][-_\w]*)[^=?]*$/ end
+      def read_untyped_method?() /^([a-zA-Z][-_\w]*)_before_type_cast$/ end
+      def write_method?()        /^([a-zA-Z][-_\w]*)=.*$/    end
+      def query_method?()        /^([a-zA-Z][-_\w]*)\?$/     end
 
-      # Returns the value of attribute identified by <tt>attr_name</tt> after it has been type cast (for example, 
+      # Returns the value of attribute identified by <tt>attr_name</tt> after it has been type cast (for example,
       # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)).
       def read_attribute(attr_name) #:doc:
         if @attributes.keys.include? attr_name
           if column = column_for_attribute(attr_name)
-            @attributes[attr_name] = unserializable_attribute?(attr_name, column) ?
+            unserializable_attribute?(attr_name, column) ?
               unserialize_attribute(attr_name) : column.type_cast(@attributes[attr_name])
+          else
+            @attributes[attr_name]
           end
-          
-          @attributes[attr_name]
         else
           nil
         end
       end
 
+      def read_attribute_before_type_cast(attr_name)
+        @attributes[attr_name]
+      end
+
       # Returns true if the attribute is of a text column and marked for serialization.
       def unserializable_attribute?(attr_name, column)
         @attributes[attr_name] && column.send(:type) == :text && @attributes[attr_name].is_a?(String) && self.class.serialized_attributes[attr_name]

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -86,14 +86,13 @@ module ActiveRecord
           if configuration = configurations[spec.to_s]
             establish_connection(configuration)
           else
-            raise AdapterNotSpecified
+            raise AdapterNotSpecified, "#{spec} database is not configured"
           end
         else
           spec = symbolize_strings_in_hash(spec)
-          unless spec.key?(:adapter) then raise AdapterNotSpecified end
-
+          unless spec.key?(:adapter) then raise AdapterNotSpecified, "database configuration does not specify adapter" end
           adapter_method = "#{spec[:adapter]}_connection"
-          unless respond_to?(adapter_method) then raise AdapterNotFound end
+          unless respond_to?(adapter_method) then raise AdapterNotFound, "database configuration specifies nonexistent #{spec[:adapter]} adapter" end
           remove_connection
           establish_connection(ConnectionSpecification.new(spec, adapter_method))
       end
@@ -285,10 +284,10 @@ module ActiveRecord
       # Returns the last auto-generated ID from the affected table.
       def insert(sql, name = nil, pk = nil, id_value = nil) end
 
-      # Executes the update statement.
+      # Executes the update statement and returns the number of rows affected.
       def update(sql, name = nil) end
 
-      # Executes the delete statement.
+      # Executes the delete statement and returns the number of rows affected.
       def delete(sql, name = nil) end
 
       def reset_runtime # :nodoc:
@@ -298,16 +297,16 @@ module ActiveRecord
       end
 
       # Wrap a block in a transaction.  Returns result of block.
-      def transaction
+      def transaction(start_db_transaction = true)
         begin
           if block_given?
-            begin_db_transaction
+            begin_db_transaction if start_db_transaction
             result = yield
-            commit_db_transaction
+            commit_db_transaction if start_db_transaction
             result
           end
         rescue Exception => database_transaction_rollback
-          rollback_db_transaction
+          rollback_db_transaction if start_db_transaction
           raise
         end
       end
@@ -349,7 +348,7 @@ module ActiveRecord
       protected
         def log(sql, name, connection, &action)
           begin
-            if @logger.nil?
+            if @logger.nil? || @logger.level > Logger::INFO
               action.call(connection)
             else
               result = nil

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -67,8 +67,12 @@ module ActiveRecord
         log(sql, name, @connection) { |connection| connection.query(sql) }
       end
 
-      alias_method :update, :execute
-      alias_method :delete, :execute
+      def update(sql, name = nil)
+        execute(sql, name)
+        @connection.affected_rows
+      end
+
+      alias_method :delete, :update
       
       def begin_db_transaction
         begin

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -64,8 +64,13 @@ module ActiveRecord
         log(sql, name, @connection) { |connection| connection.query(sql) }
       end
 
-      alias_method :update, :execute
-      alias_method :delete, :execute
+      def update(sql, name = nil)
+        result = nil
+        log(sql, name, @connection) { |connection| result = connection.exec(sql) }
+        result.cmdtuples
+      end
+
+      alias_method :delete, :update
 
       def begin_db_transaction()    execute "BEGIN" end
       def commit_db_transaction()   execute "COMMIT" end

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -62,8 +62,16 @@ module ActiveRecord
         end
       end
 
-      alias_method :update, :execute
-      alias_method :delete, :execute
+      def update(sql, name = nil)
+        execute(sql, name)
+        @connection.changes
+      end
+      
+      def delete(sql, name = nil)
+        sql += " WHERE 1=1" unless sql =~ /WHERE/i
+        execute(sql, name)
+        @connection.changes
+      end
 
       def begin_db_transaction()    execute "BEGIN" end
       def commit_db_transaction()   execute "COMMIT" end