activerecord 3.0.0.beta3 → 3.0.0.beta4

data/CHANGELOG

@@ -1,3 +1,30 @@
+*Rails 3.0.0 [beta 4] (June 8th, 2010)*
+
+* Fixed that ActiveRecord::Base.compute_type would swallow NoMethodError #4751 [Andrew Bloomgarden, Andrew White]
+
+* Add index length support for MySQL. #1852 [Emili Parreno, Pratik Naik]
+
+  Example:
+
+    add_index(:accounts, :name, :name => 'by_name', :length => 10)
+    => CREATE INDEX by_name ON accounts(name(10))
+
+    add_index(:accounts, [:name, :surname], :name => 'by_name_surname', :length => {:name => 10, :surname => 15})
+    => CREATE INDEX by_name_surname ON accounts(name(10), surname(15))
+
+* find_or_create_by_attr(value, ...) works when attr is protected.  #4457 [Santiago Pastorino, Marc-André Lafortune]
+
+* New callbacks: after_commit and after_rollback. Do expensive operations like image thumbnailing after_commit instead of after_save.  #2991 [Brian Durand]
+
+* Serialized attributes are not converted to YAML if they are any of the formats that can be serialized to XML (like Hash, Array and Strings). [José Valim]
+
+* Destroy uses optimistic locking. If lock_version on the record you're destroying doesn't match lock_version in the database, a StaleObjectError is raised.  #1966 [Curtis Hawthorne]
+
+* PostgreSQL: drop support for old postgres driver. Use pg 0.9.0 or later.  [Jeremy Kemper]
+
+* Observers can prevent records from saving by returning false, just like before_save and friends.  #4087 [Mislav Marohnić]
+
+
 *Rails 3.0.0 [beta 3] (April 13th, 2010)*
 
 * Add Relation extensions. [Pratik Naik]

data/lib/active_record.rb

@@ -29,7 +29,9 @@ activemodel_path = File.expand_path('../../../activemodel/lib', __FILE__)
 $:.unshift(activemodel_path) if File.directory?(activemodel_path) && !$:.include?(activemodel_path)
 
 require 'active_support'
+require 'active_support/i18n'
 require 'active_model'
+require 'arel'
 
 module ActiveRecord
   extend ActiveSupport::Autoload
@@ -59,6 +61,7 @@ module ActiveRecord
 
     autoload :Base
     autoload :Callbacks
+    autoload :CounterCache
     autoload :DynamicFinderMatch
     autoload :DynamicScopeMatch
     autoload :Migration
@@ -66,6 +69,7 @@ module ActiveRecord
     autoload :NamedScope
     autoload :NestedAttributes
     autoload :Observer
+    autoload :Persistence
     autoload :QueryCache
     autoload :Reflection
     autoload :Schema
@@ -117,4 +121,4 @@ ActiveSupport.on_load(:active_record) do
   Arel::Table.engine = Arel::Sql::Engine.new(self)
 end
 
-I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'
+I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'

data/lib/active_record/aggregations.rb

@@ -253,6 +253,7 @@ module ActiveRecord
                       raise ArgumentError, 'Converter must be a symbol denoting the converter method to call or a Proc to be invoked.'
                     end
                 end
+
                 mapping.each { |pair| self[pair.first] = part.send(pair.last) }
                 instance_variable_set("@#{name}", part.freeze)
               end

data/lib/active_record/association_preload.rb

@@ -378,7 +378,7 @@ module ActiveRecord
 
 
       def interpolate_sql_for_preload(sql)
-        instance_eval("%@#{sql.gsub('@', '\@')}@")
+        instance_eval("%@#{sql.gsub('@', '\@')}@", __FILE__, __LINE__)
       end
 
       def append_conditions(reflection, preload_options)

data/lib/active_record/associations.rb

@@ -2,6 +2,7 @@ require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/conversions'
 
 module ActiveRecord
   class InverseOfAssociationNotFoundError < ActiveRecordError #:nodoc:
@@ -839,10 +840,11 @@ module ActiveRecord
       #   If set to <tt>:destroy</tt> all the associated objects are destroyed
       #   alongside this object by calling their +destroy+ method.  If set to <tt>:delete_all</tt> all associated
       #   objects are deleted *without* calling their +destroy+ method.  If set to <tt>:nullify</tt> all associated
-      #   objects' foreign keys are set to +NULL+ *without* calling their +save+ callbacks. *Warning:* This option is ignored when also using
-      #   the <tt>:through</tt> option.
-      #   the <tt>:through</tt> option. If set to <tt>:restrict</tt>
-      #   this object cannot be deleted if it has any associated object.
+      #   objects' foreign keys are set to +NULL+ *without* calling their +save+ callbacks. If set to
+      #   <tt>:restrict</tt> this object cannot be deleted if it has any associated object.
+      #
+      #   *Warning:* This option is ignored when used with <tt>:through</tt> option.
+      #
       # [:finder_sql]
       #   Specify a complete SQL statement to fetch the association. This is a good way to go for complex
       #   associations that depend on multiple tables. Note: When this option is used, +find_in_collection+ is _not_ added.
@@ -1304,14 +1306,14 @@ module ActiveRecord
 
         # Don't use a before_destroy callback since users' before_destroy
         # callbacks will be executed after the association is wiped out.
-        old_method = "destroy_without_habtm_shim_for_#{reflection.name}"
-        class_eval <<-end_eval unless method_defined?(old_method)
-          alias_method :#{old_method}, :destroy_without_callbacks  # alias_method :destroy_without_habtm_shim_for_posts, :destroy_without_callbacks
-          def destroy_without_callbacks                            # def destroy_without_callbacks
-            #{reflection.name}.clear                               #   posts.clear
-            #{old_method}                                          #   destroy_without_habtm_shim_for_posts
-          end                                                      # end
-        end_eval
+        include Module.new {
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def destroy                     # def destroy
+              super                         #   super
+              #{reflection.name}.clear      #   posts.clear
+            end                             # end
+          RUBY
+        }
 
         add_association_callbacks(reflection.name, options)
       end
@@ -1398,7 +1400,7 @@ module ActiveRecord
                 primary_key = reflection.source_reflection.primary_key_name
                 send(through.name).select("DISTINCT #{through.quoted_table_name}.#{primary_key}").map!(&:"#{primary_key}")
               else
-                send(reflection.name).select("#{reflection.quoted_table_name}.#{reflection.klass.primary_key}").map!(&:id)
+                send(reflection.name).select("#{reflection.quoted_table_name}.#{reflection.klass.primary_key}").except(:includes).map!(&:id)
               end
             end
           end
@@ -1460,7 +1462,7 @@ module ActiveRecord
           before_destroy(method_name)
 
           module_eval(
-            "#{reflection.class_name}.send(:attr_readonly,\"#{cache_column}\".intern) if defined?(#{reflection.class_name}) && #{reflection.class_name}.respond_to?(:attr_readonly)"
+            "#{reflection.class_name}.send(:attr_readonly,\"#{cache_column}\".intern) if defined?(#{reflection.class_name}) && #{reflection.class_name}.respond_to?(:attr_readonly)", __FILE__, __LINE__
           )
         end
 
@@ -1500,7 +1502,16 @@ module ActiveRecord
               when :destroy
                 method_name = "has_many_dependent_destroy_for_#{reflection.name}".to_sym
                 define_method(method_name) do
-                  send(reflection.name).each { |o| o.destroy }
+                  send(reflection.name).each do |o|
+                    # No point in executing the counter update since we're going to destroy the parent anyway
+                    counter_method = ('belongs_to_counter_cache_before_destroy_for_' + self.class.name.downcase).to_sym
+                    if(o.respond_to? counter_method) then
+                      class << o
+                        self
+                      end.send(:define_method, counter_method, Proc.new {})
+                    end
+                    o.destroy
+                  end
                 end
                 before_destroy method_name
               when :delete_all
@@ -1728,6 +1739,14 @@ module ActiveRecord
             build(associations)
           end
 
+          def graft(*associations)
+            associations.each do |association|
+              join_associations.detect {|a| association == a} ||
+              build(association.reflection.name, association.find_parent_in(self), association.join_class)
+            end
+            self
+          end
+
           def join_associations
             @joins[1..-1].to_a
           end
@@ -1736,6 +1755,17 @@ module ActiveRecord
             @joins[0]
           end
 
+          def count_aliases_from_table_joins(name)
+            # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
+            quoted_name = join_base.active_record.connection.quote_table_name(name.downcase).downcase
+            join_sql = join_base.table_joins.to_s.downcase
+            join_sql.blank? ? 0 :
+              # Table names
+              join_sql.scan(/join(?:\s+\w+)?\s+#{quoted_name}\son/).size +
+              # Table aliases
+              join_sql.scan(/join(?:\s+\w+)?\s+\S+\s+#{quoted_name}\son/).size
+          end
+
           def instantiate(rows)
             rows.each_with_index do |row, i|
               primary_id = join_base.record_id(row)
@@ -1780,22 +1810,22 @@ module ActiveRecord
           end
 
           protected
-            def build(associations, parent = nil)
+            def build(associations, parent = nil, join_class = Arel::InnerJoin)
               parent ||= @joins.last
               case associations
                 when Symbol, String
                   reflection = parent.reflections[associations.to_s.intern] or
                   raise ConfigurationError, "Association named '#{ associations }' was not found; perhaps you misspelled it?"
                   @reflections << reflection
-                  @joins << build_join_association(reflection, parent)
+                  @joins << build_join_association(reflection, parent).with_join_class(join_class)
                 when Array
                   associations.each do |association|
-                    build(association, parent)
+                    build(association, parent, join_class)
                   end
                 when Hash
                   associations.keys.sort{|a,b|a.to_s<=>b.to_s}.each do |name|
-                    build(name, parent)
-                    build(associations[name])
+                    build(name, parent, join_class)
+                    build(associations[name], nil, join_class)
                   end
                 else
                   raise ConfigurationError, associations.inspect
@@ -1872,6 +1902,12 @@ module ActiveRecord
               @table_joins   = joins
             end
 
+            def ==(other)
+              other.class == self.class &&
+              other.active_record == active_record &&
+              other.table_joins == table_joins
+            end
+
             def aliased_prefix
               "t0"
             end
@@ -1937,6 +1973,27 @@ module ActiveRecord
               end
             end
 
+            def ==(other)
+              other.class == self.class &&
+              other.reflection == reflection &&
+              other.parent == parent
+            end
+
+            def find_parent_in(other_join_dependency)
+              other_join_dependency.joins.detect do |join|
+                self.parent == join
+              end
+            end
+
+            def join_class
+              @join_class ||= Arel::InnerJoin
+            end
+
+            def with_join_class(join_class)
+              @join_class = join_class
+              self
+            end
+
             def association_join
               return @join if @join
 
@@ -2036,27 +2093,25 @@ module ActiveRecord
             end
 
             def join_relation(joining_relation, join = nil)
-              if (relations = relation).is_a?(Array)
-                joining_relation.joins(Relation::JoinOperation.new(relations.first, Arel::OuterJoin, association_join.first)).
-                  joins(Relation::JoinOperation.new(relations.last, Arel::OuterJoin, association_join.last))
-              else
-                joining_relation.joins(Relation::JoinOperation.new(relations, Arel::OuterJoin, association_join))
-              end
+              joining_relation.joins(self.with_join_class(Arel::OuterJoin))
             end
 
             protected
 
               def aliased_table_name_for(name, suffix = nil)
-                if !parent.table_joins.blank? && parent.table_joins.to_s.downcase =~ %r{join(\s+\w+)?\s+#{active_record.connection.quote_table_name name.downcase}\son}
-                  @join_dependency.table_aliases[name] += 1
+                if @join_dependency.table_aliases[name].zero?
+                  @join_dependency.table_aliases[name] = @join_dependency.count_aliases_from_table_joins(name)
                 end
 
-                unless @join_dependency.table_aliases[name].zero?
-                  # if the table name has been used, then use an alias
+                if !@join_dependency.table_aliases[name].zero? # We need an alias
                   name = active_record.connection.table_alias_for "#{pluralize(reflection.name)}_#{parent_table_name}#{suffix}"
-                  table_index = @join_dependency.table_aliases[name]
                   @join_dependency.table_aliases[name] += 1
-                  name = name[0..active_record.connection.table_alias_length-3] + "_#{table_index+1}" if table_index > 0
+                  if @join_dependency.table_aliases[name] == 1 # First time we've seen this name
+                    # Also need to count the aliases from the table_aliases to avoid incorrect count
+                    @join_dependency.table_aliases[name] += @join_dependency.count_aliases_from_table_joins(name)
+                  end
+                  table_index = @join_dependency.table_aliases[name]
+                  name = name[0..active_record.connection.table_alias_length-3] + "_#{table_index}" if table_index > 1
                 else
                   @join_dependency.table_aliases[name] += 1
                 end
@@ -2077,7 +2132,7 @@ module ActiveRecord
               end
 
               def interpolate_sql(sql)
-                instance_eval("%@#{sql.gsub('@', '\@')}@")
+                instance_eval("%@#{sql.gsub('@', '\@')}@", __FILE__, __LINE__)
               end
           end
         end

data/lib/active_record/associations/association_collection.rb

@@ -411,7 +411,8 @@ module ActiveRecord
             end
           elsif @reflection.klass.scopes[method]
             @_named_scopes_cache ||= {}
-            @_named_scopes_cache[method] ||= with_scope(construct_scope) { @reflection.klass.send(method, *args) }
+            @_named_scopes_cache[method] ||= {}
+            @_named_scopes_cache[method][args] ||= with_scope(construct_scope) { @reflection.klass.send(method, *args) }
           else
             with_scope(construct_scope) do
               if block_given?
@@ -451,6 +452,16 @@ module ActiveRecord
           records
         end
 
+        def add_record_to_target_with_callbacks(record)
+          callback(:before_add, record)
+          yield(record) if block_given?
+          @target ||= [] unless loaded?
+          @target << record unless @reflection.options[:uniq] && @target.include?(record)
+          callback(:after_add, record)
+          set_inverse_instance(record, @owner)
+          record
+        end
+
       private
         def create_record(attrs)
           attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
@@ -475,16 +486,6 @@ module ActiveRecord
           end
         end
 
-        def add_record_to_target_with_callbacks(record)
-          callback(:before_add, record)
-          yield(record) if block_given?
-          @target ||= [] unless loaded?
-          @target << record unless @reflection.options[:uniq] && @target.include?(record)
-          callback(:after_add, record)
-          set_inverse_instance(record, @owner)
-          record
-        end
-
         def remove_records(*records)
           records = flatten_deeper(records)
           records.each { |record| raise_on_type_mismatch(record) }

data/lib/active_record/associations/association_proxy.rb

@@ -51,7 +51,7 @@ module ActiveRecord
       alias_method :proxy_respond_to?, :respond_to?
       alias_method :proxy_extend, :extend
       delegate :to_param, :to => :proxy_target
-      instance_methods.each { |m| undef_method m unless m =~ /^(?:nil\?|send|object_id|to_a)$|^__|proxy_/ }
+      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|proxy_/ }
 
       def initialize(owner, reflection)
         @owner, @reflection = owner, reflection

data/lib/active_record/attribute_methods.rb

@@ -18,10 +18,19 @@ module ActiveRecord
       def instance_method_already_implemented?(method_name)
         method_name = method_name.to_s
         @_defined_class_methods         ||= ancestors.first(ancestors.index(ActiveRecord::Base)).sum([]) { |m| m.public_instance_methods(false) | m.private_instance_methods(false) | m.protected_instance_methods(false) }.map {|m| m.to_s }.to_set
-        @@_defined_activerecord_methods ||= (ActiveRecord::Base.public_instance_methods(false) | ActiveRecord::Base.private_instance_methods(false) | ActiveRecord::Base.protected_instance_methods(false)).map{|m| m.to_s }.to_set
+        @@_defined_activerecord_methods ||= defined_activerecord_methods
         raise DangerousAttributeError, "#{method_name} is defined by ActiveRecord" if @@_defined_activerecord_methods.include?(method_name)
         @_defined_class_methods.include?(method_name)
       end
+
+      def defined_activerecord_methods
+        active_record = ActiveRecord::Base
+        super_klass   = ActiveRecord::Base.superclass
+        methods =  active_record.public_instance_methods - super_klass.public_instance_methods
+        methods += active_record.private_instance_methods - super_klass.private_instance_methods
+        methods += active_record.protected_instance_methods - super_klass.protected_instance_methods
+        methods.map {|m| m.to_s }.to_set
+      end
     end
 
     def method_missing(method_id, *args, &block)

data/lib/active_record/attribute_methods/dirty.rb

@@ -5,20 +5,20 @@ module ActiveRecord
     module Dirty
       extend ActiveSupport::Concern
       include ActiveModel::Dirty
+      include AttributeMethods::Write
 
       included do
-        alias_method_chain :save,   :dirty
-        alias_method_chain :save!,  :dirty
-        alias_method_chain :update, :dirty
-        alias_method_chain :reload, :dirty
+        if self < ::ActiveRecord::Timestamp
+          raise "You cannot include Dirty after Timestamp"
+        end
 
         superclass_delegating_accessor :partial_updates
         self.partial_updates = true
       end
 
       # Attempts to +save+ the record and clears changed attributes if successful.
-      def save_with_dirty(*args) #:nodoc:
-        if status = save_without_dirty(*args)
+      def save(*) #:nodoc:
+        if status = super
           @previously_changed = changes
           @changed_attributes.clear
         end
@@ -26,70 +26,70 @@ module ActiveRecord
       end
 
       # Attempts to <tt>save!</tt> the record and clears changed attributes if successful.
-      def save_with_dirty!(*args) #:nodoc:
-        save_without_dirty!(*args).tap do
+      def save!(*) #:nodoc:
+        super.tap do
           @previously_changed = changes
           @changed_attributes.clear
         end
       end
 
       # <tt>reload</tt> the record and clears changed attributes.
-      def reload_with_dirty(*args) #:nodoc:
-        reload_without_dirty(*args).tap do
+      def reload(*) #:nodoc:
+        super.tap do
           @previously_changed.clear
           @changed_attributes.clear
         end
       end
 
-      private
-        # Wrap write_attribute to remember original attribute value.
-        def write_attribute(attr, value)
-          attr = attr.to_s
+    private
+      # Wrap write_attribute to remember original attribute value.
+      def write_attribute(attr, value)
+        attr = attr.to_s
 
-          # The attribute already has an unsaved change.
-          if attribute_changed?(attr)
-            old = @changed_attributes[attr]
-            @changed_attributes.delete(attr) unless field_changed?(attr, old, value)
-          else
-            old = clone_attribute_value(:read_attribute, attr)
-            # Save Time objects as TimeWithZone if time_zone_aware_attributes == true
-            old = old.in_time_zone if clone_with_time_zone_conversion_attribute?(attr, old)
-            @changed_attributes[attr] = old if field_changed?(attr, old, value)
-          end
+        # The attribute already has an unsaved change.
+        if attribute_changed?(attr)
+          old = @changed_attributes[attr]
+          @changed_attributes.delete(attr) unless field_changed?(attr, old, value)
+        else
+          old = clone_attribute_value(:read_attribute, attr)
+          # Save Time objects as TimeWithZone if time_zone_aware_attributes == true
+          old = old.in_time_zone if clone_with_time_zone_conversion_attribute?(attr, old)
+          @changed_attributes[attr] = old if field_changed?(attr, old, value)
+        end
 
-          # Carry on.
-          super(attr, value)
+        # Carry on.
+        super(attr, value)
+      end
+
+      def update(*)
+        if partial_updates?
+          # Serialized attributes should always be written in case they've been
+          # changed in place.
+          super(changed | (attributes.keys & self.class.serialized_attributes.keys))
+        else
+          super
         end
+      end
 
-        def update_with_dirty
-          if partial_updates?
-            # Serialized attributes should always be written in case they've been
-            # changed in place.
-            update_without_dirty(changed | (attributes.keys & self.class.serialized_attributes.keys))
+      def field_changed?(attr, old, value)
+        if column = column_for_attribute(attr)
+          if column.number? && column.null && (old.nil? || old == 0) && value.blank?
+            # For nullable numeric columns, NULL gets stored in database for blank (i.e. '') values.
+            # Hence we don't record it as a change if the value changes from nil to ''.
+            # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
+            # be typecast back to 0 (''.to_i => 0)
+            value = nil
           else
-            update_without_dirty
+            value = column.type_cast(value)
           end
         end
 
-        def field_changed?(attr, old, value)
-          if column = column_for_attribute(attr)
-            if column.number? && column.null && (old.nil? || old == 0) && value.blank?
-              # For nullable numeric columns, NULL gets stored in database for blank (i.e. '') values.
-              # Hence we don't record it as a change if the value changes from nil to ''.
-              # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
-              # be typecast back to 0 (''.to_i => 0)
-              value = nil
-            else
-              value = column.type_cast(value)
-            end
-          end
-
-          old != value
-        end
+        old != value
+      end
 
-        def clone_with_time_zone_conversion_attribute?(attr, old)
-          old.class.name == "Time" && time_zone_aware_attributes && !skip_time_zone_conversion_for_attributes.include?(attr.to_sym)
-        end
+      def clone_with_time_zone_conversion_attribute?(attr, old)
+        old.class.name == "Time" && time_zone_aware_attributes && !skip_time_zone_conversion_for_attributes.include?(attr.to_sym)
+      end
     end
   end
 end