activerecord 3.0.0 → 3.0.3

data/CHANGELOG

@@ -1,3 +1,45 @@
+*Rails 3.0.3 (November 16, 2010)*
+
+* Support find by class like this: Post.where(:name => Post)
+
+
+*Rails 3.0.2 (November 15, 2010)*
+
+* Dramatic speed increase (see: http://engineering.attinteractive.com/2010/10/arel-two-point-ohhhhh-yaaaaaa/) [Aaron Patterson]
+
+* reorder is deprecated in favor of except(:order).order(...) [Santiago Pastorino]
+
+* except is now AR public API
+
+    Model.order('name').except(:order).order('salary')
+
+  generates:
+
+    SELECT * FROM models ORDER BY salary
+
+  [Santiago Pastorino]
+
+* The following code:
+
+    Model.limit(10).scoping { Model.count }
+
+  now generates the following SQL:
+
+    SELECT COUNT(*) FROM models LIMIT 10
+
+  This may not return what you want.  Instead, you may with to do something
+  like this:
+
+    Model.limit(10).scoping { Model.all.size }
+
+  [Aaron Patterson]
+
+
+*Rails 3.0.1 (October 15, 2010)*
+
+* Introduce a fix for CVE-2010-3993
+
+
 *Rails 3.0.0 (August 29, 2010)*
 
 * Changed update_attribute to not run callbacks and update the record directly in the database [Neeraj Singh]

data/examples/performance.rb

@@ -25,7 +25,7 @@ conn[:socket] = Pathname.glob(%w[
   /tmp/mysql.sock
   /var/mysql/mysql.sock
   /var/run/mysqld/mysqld.sock
-]).find { |path| path.socket? }
+]).find { |path| path.socket? }.to_s
 
 ActiveRecord::Base.establish_connection(conn)
 
@@ -155,6 +155,23 @@ RBench.run(TIMES) do
     ar { Exhibit.transaction { Exhibit.new } }
   end
 
+  report 'Model.find(id)' do
+    id = Exhibit.first.id
+    ar { Exhibit.find(id) }
+  end
+
+  report 'Model.find_by_sql' do
+    ar { Exhibit.find_by_sql("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}").first }
+  end
+
+  report 'Model.log', (TIMES * 10) do
+    ar { Exhibit.connection.send(:log, "hello", "world") {} }
+  end
+
+  report 'AR.execute(query)', (TIMES / 2) do
+    ar { ActiveRecord::Base.connection.execute("Select * from exhibits where id = #{(rand * 1000 + 1).to_i}") }
+  end
+
   summary 'Total'
 end
 

data/lib/active_record.rb

@@ -33,12 +33,12 @@ require 'active_support/i18n'
 require 'active_model'
 require 'arel'
 
+require 'active_record/version'
+
 module ActiveRecord
   extend ActiveSupport::Autoload
 
   eager_autoload do
-    autoload :VERSION
-
     autoload :ActiveRecordError, 'active_record/errors'
     autoload :ConnectionNotEstablished, 'active_record/errors'
 
@@ -118,7 +118,7 @@ module ActiveRecord
 end
 
 ActiveSupport.on_load(:active_record) do
-  Arel::Table.engine = Arel::Sql::Engine.new(self)
+  Arel::Table.engine = self
 end
 
 I18n.load_path << File.dirname(__FILE__) + '/active_record/locale/en.yml'

data/lib/active_record/aggregations.rb

@@ -6,7 +6,7 @@ module ActiveRecord
     def clear_aggregation_cache #:nodoc:
       self.class.reflect_on_all_aggregations.to_a.each do |assoc|
         instance_variable_set "@#{assoc.name}", nil
-      end unless self.new_record?
+      end if self.persisted?
     end
 
     # Active Record implements aggregation through a macro-like class method called +composed_of+
@@ -161,7 +161,7 @@ module ActiveRecord
     # by specifying an instance of the value object in the conditions hash. The following example
     # finds all customers with +balance_amount+ equal to 20 and +balance_currency+ equal to "USD":
     #
-    #   Customer.find(:all, :conditions => {:balance => Money.new(20, "USD")})
+    #   Customer.where(:balance => Money.new(20, "USD")).all
     #
     module ClassMethods
       # Adds reader and writer methods for manipulating a value object:

data/lib/active_record/association_preload.rb

@@ -284,7 +284,7 @@ module ActiveRecord
           end
         else
           options = {}
-          options[:include] = reflection.options[:include] || reflection.options[:source] if reflection.options[:conditions]
+          options[:include] = reflection.options[:include] || reflection.options[:source] if reflection.options[:conditions] || reflection.options[:order]
           options[:order] = reflection.options[:order]
           options[:conditions] = reflection.options[:conditions]
           records.first.class.preload_associations(records, through_association, options)

data/lib/active_record/associations.rb

@@ -118,7 +118,7 @@ module ActiveRecord
     def clear_association_cache #:nodoc:
       self.class.reflect_on_all_associations.to_a.each do |assoc|
         instance_variable_set "@#{assoc.name}", nil
-      end unless self.new_record?
+      end if self.persisted?
     end
 
     private
@@ -602,7 +602,7 @@ module ActiveRecord
     # other than the main one. If this is the case Active Record falls back to the previously
     # used LEFT OUTER JOIN based strategy. For example
     #
-    #   Post.find(:all, :include => [ :author, :comments ], :conditions => ['comments.approved = ?', true])
+    #   Post.includes([:author, :comments]).where(['comments.approved = ?', true]).all
     #
     # This will result in a single SQL query with joins along the lines of:
     # <tt>LEFT OUTER JOIN comments ON comments.post_id = posts.id</tt> and
@@ -1416,8 +1416,8 @@ module ActiveRecord
         include Module.new {
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def destroy                     # def destroy
-              super                         #   super
               #{reflection.name}.clear      #   posts.clear
+              super                         #   super
             end                             # end
           RUBY
         }
@@ -1840,7 +1840,7 @@ module ActiveRecord
 
           def initialize(base, associations, joins)
             @joins                 = [JoinBase.new(base, joins)]
-            @associations          = associations
+            @associations          = {}
             @reflections           = []
             @base_records_hash     = {}
             @base_records_in_order = []
@@ -1852,7 +1852,7 @@ module ActiveRecord
           def graft(*associations)
             associations.each do |association|
               join_associations.detect {|a| association == a} ||
-              build(association.reflection.name, association.find_parent_in(self) || join_base, association.join_class)
+              build(association.reflection.name, association.find_parent_in(self) || join_base, association.join_type)
             end
             self
           end
@@ -1920,28 +1920,57 @@ module ActiveRecord
 
           protected
 
-            def build(associations, parent = nil, join_class = Arel::InnerJoin)
+            def cache_joined_association(association)
+              associations = []
+              parent = association.parent
+              while parent != join_base
+                associations.unshift(parent.reflection.name)
+                parent = parent.parent
+              end
+              ref = @associations
+              associations.each do |key|
+                ref = ref[key]
+              end
+              ref[association.reflection.name] ||= {}
+            end
+
+            def build(associations, parent = nil, join_type = 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).with_join_class(join_class)
+                  unless join_association = find_join_association(reflection, parent)
+                    @reflections << reflection
+                    join_association = build_join_association(reflection, parent)
+                    join_association.join_type = join_type
+                    @joins << join_association
+                    cache_joined_association(join_association)
+                  end
+                  join_association
                 when Array
                   associations.each do |association|
-                    build(association, parent, join_class)
+                    build(association, parent, join_type)
                   end
                 when Hash
                   associations.keys.sort{|a,b|a.to_s<=>b.to_s}.each do |name|
-                    build(name, parent, join_class)
-                    build(associations[name], nil, join_class)
+                    join_association = build(name, parent, join_type)
+                    build(associations[name], join_association, join_type)
                   end
                 else
                   raise ConfigurationError, associations.inspect
               end
             end
 
+            def find_join_association(name_or_reflection, parent)
+              case name_or_reflection
+              when Symbol, String
+                join_associations.detect {|j| (j.reflection.name == name_or_reflection.to_s.intern) && (j.parent == parent)}
+              else
+                join_associations.detect {|j| (j.reflection == name_or_reflection) && (j.parent == parent)}
+              end
+            end
+
             def remove_uniq_by_reflection(reflection, records)
               if reflection && reflection.collection?
                 records.each { |record| record.send(reflection.name).target.uniq! }
@@ -2020,8 +2049,7 @@ module ActiveRecord
 
             def ==(other)
               other.class == self.class &&
-              other.active_record == active_record &&
-              other.table_joins == table_joins
+              other.active_record == active_record
             end
 
             def aliased_prefix
@@ -2049,7 +2077,7 @@ module ActiveRecord
             end
 
             def extract_record(row)
-              column_names_with_alias.inject({}){|record, (cn, an)| record[cn] = row[an]; record}
+              Hash[column_names_with_alias.map{|cn, an| [cn, row[an]]}]
             end
 
             def record_id(row)
@@ -2062,7 +2090,9 @@ module ActiveRecord
           end
 
           class JoinAssociation < JoinBase # :nodoc:
-            attr_reader :reflection, :parent, :aliased_table_name, :aliased_prefix, :aliased_join_table_name, :parent_table_name, :join_class
+            attr_reader :reflection, :parent, :aliased_table_name, :aliased_prefix, :aliased_join_table_name, :parent_table_name
+            # What type of join will be generated, either Arel::InnerJoin (default) or Arel::OuterJoin
+            attr_accessor :join_type
             delegate    :options, :klass, :through_reflection, :source_reflection, :to => :reflection
 
             def initialize(reflection, join_dependency, parent = nil)
@@ -2079,7 +2109,7 @@ module ActiveRecord
               @parent_table_name  = parent.active_record.table_name
               @aliased_table_name = aliased_table_name_for(table_name)
               @join               = nil
-              @join_class         = Arel::InnerJoin
+              @join_type          = Arel::InnerJoin
 
               if reflection.macro == :has_and_belongs_to_many
                 @aliased_join_table_name = aliased_table_name_for(reflection.options[:join_table], "_join")
@@ -2102,16 +2132,16 @@ module ActiveRecord
               end
             end
 
-            def with_join_class(join_class)
-              @join_class = join_class
-              self
-            end
-
             def association_join
               return @join if @join
 
-              aliased_table = Arel::Table.new(table_name, :as => @aliased_table_name, :engine => arel_engine)
-              parent_table = Arel::Table.new(parent.table_name, :as => parent.aliased_table_name, :engine => arel_engine)
+              aliased_table = Arel::Table.new(table_name, :as      => @aliased_table_name,
+                                                          :engine  => arel_engine,
+                                                          :columns => klass.columns)
+
+              parent_table = Arel::Table.new(parent.table_name, :as      => parent.aliased_table_name,
+                                                                :engine  => arel_engine,
+                                                                :columns => parent.active_record.columns)
 
               @join = case reflection.macro
               when :has_and_belongs_to_many
@@ -2194,7 +2224,9 @@ module ActiveRecord
             end
 
             def relation
-              aliased = Arel::Table.new(table_name, :as => @aliased_table_name, :engine => arel_engine)
+              aliased = Arel::Table.new(table_name, :as => @aliased_table_name,
+                                                    :engine => arel_engine,
+                                                    :columns => klass.columns)
 
               if reflection.macro == :has_and_belongs_to_many
                 [Arel::Table.new(options[:join_table], :as => aliased_join_table_name, :engine => arel_engine), aliased]
@@ -2205,8 +2237,9 @@ module ActiveRecord
               end
             end
 
-            def join_relation(joining_relation, join = nil)
-              joining_relation.joins(self.with_join_class(Arel::OuterJoin))
+            def join_relation(joining_relation)
+              self.join_type = Arel::OuterJoin
+              joining_relation.joins(self)
             end
 
             protected

data/lib/active_record/associations/association_collection.rb

@@ -127,13 +127,13 @@ module ActiveRecord
       # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
       def <<(*records)
         result = true
-        load_target if @owner.new_record?
+        load_target unless @owner.persisted?
 
         transaction do
           flatten_deeper(records).each do |record|
             raise_on_type_mismatch(record)
             add_record_to_target_with_callbacks(record) do |r|
-              result &&= insert_record(record) unless @owner.new_record?
+              result &&= insert_record(record) if @owner.persisted?
             end
           end
         end
@@ -291,12 +291,12 @@ module ActiveRecord
       # This method is abstract in the sense that it relies on
       # +count_records+, which is a method descendants have to provide.
       def size
-        if @owner.new_record? || (loaded? && !@reflection.options[:uniq])
+        if !@owner.persisted? || (loaded? && !@reflection.options[:uniq])
           @target.size
         elsif !loaded? && @reflection.options[:group]
           load_target.size
         elsif !loaded? && !@reflection.options[:uniq] && @target.is_a?(Array)
-          unsaved_records = @target.select { |r| r.new_record? }
+          unsaved_records = @target.reject { |r| r.persisted? }
           unsaved_records.size + count_records
         else
           count_records
@@ -338,13 +338,12 @@ module ActiveRecord
 
       def uniq(collection = self)
         seen = Set.new
-        collection.inject([]) do |kept, record|
+        collection.map do |record|
           unless seen.include?(record.id)
-            kept << record
             seen << record.id
+            record
           end
-          kept
-        end
+        end.compact
       end
 
       # Replace this collection with +other_array+
@@ -364,6 +363,7 @@ module ActiveRecord
 
       def include?(record)
         return false unless record.is_a?(@reflection.klass)
+        return include_in_memory?(record) unless record.persisted?
         load_target if @reflection.options[:finder_sql] && !loaded?
         return @target.include?(record) if loaded?
         exists?(record)
@@ -390,7 +390,7 @@ module ActiveRecord
         end
 
         def load_target
-          if !@owner.new_record? || foreign_key_present
+          if @owner.persisted? || foreign_key_present
             begin
               if !loaded?
                 if @target.is_a?(Array) && @target.any?
@@ -493,11 +493,9 @@ module ActiveRecord
           attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
           ensure_owner_is_not_new
 
-          _scope = self.construct_scope[:create]
-          csm = @reflection.klass.send(:current_scoped_methods)
-          options = (csm.blank? || !_scope.is_a?(Hash)) ? _scope : _scope.merge(csm.where_values_hash)
-
-          record = @reflection.klass.send(:with_scope, :create => options) do
+          scoped_where = scoped.where_values_hash
+          create_scope = scoped_where ? construct_scope[:create].merge(scoped_where) : construct_scope[:create]
+          record = @reflection.klass.send(:with_scope, :create => create_scope) do
             @reflection.build_association(attrs)
           end
           if block_given?
@@ -523,7 +521,7 @@ module ActiveRecord
 
           transaction do
             records.each { |record| callback(:before_remove, record) }
-            old_records = records.reject { |r| r.new_record? }
+            old_records = records.select { |r| r.persisted? }
             yield(records, old_records)
             records.each { |record| callback(:after_remove, record) }
           end
@@ -548,14 +546,26 @@ module ActiveRecord
         end
 
         def ensure_owner_is_not_new
-          if @owner.new_record?
+          unless @owner.persisted?
             raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
           end
         end
 
         def fetch_first_or_last_using_find?(args)
-          args.first.kind_of?(Hash) || !(loaded? || @owner.new_record? || @reflection.options[:finder_sql] ||
-                                         @target.any? { |record| record.new_record? } || args.first.kind_of?(Integer))
+          args.first.kind_of?(Hash) || !(loaded? || !@owner.persisted? || @reflection.options[:finder_sql] ||
+                                         !@target.all? { |record| record.persisted? } || args.first.kind_of?(Integer))
+        end
+
+        def include_in_memory?(record)
+          if @reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+            @owner.send(proxy_reflection.through_reflection.name.to_sym).map do |source|
+              source_reflection_target = source.send(proxy_reflection.source_reflection.name)
+              return true if source_reflection_target.respond_to?(:include?) ? source_reflection_target.include?(record) : source_reflection_target == record
+            end
+            false
+          else
+            @target.include?(record)
+          end
         end
     end
   end

data/lib/active_record/associations/association_proxy.rb

@@ -53,7 +53,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.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|proxy_/ }
+      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to_missing|proxy_/ }
 
       def initialize(owner, reflection)
         @owner, @reflection = owner, reflection
@@ -174,10 +174,10 @@ module ActiveRecord
         # If the association is polymorphic the type of the owner is also set.
         def set_belongs_to_association_for(record)
           if @reflection.options[:as]
-            record["#{@reflection.options[:as]}_id"]   = @owner.id unless @owner.new_record?
+            record["#{@reflection.options[:as]}_id"]   = @owner.id if @owner.persisted?
             record["#{@reflection.options[:as]}_type"] = @owner.class.base_class.name.to_s
           else
-            unless @owner.new_record?
+            if @owner.persisted?
               primary_key = @reflection.options[:primary_key] || :id
               record[@reflection.primary_key_name] = @owner.send(primary_key)
             end
@@ -233,7 +233,7 @@ module ActiveRecord
         def load_target
           return nil unless defined?(@loaded)
 
-          if !loaded? and (!@owner.new_record? || foreign_key_present)
+          if !loaded? and (@owner.persisted? || foreign_key_present)
             @target = find_target
           end