activerecord 3.0.0 → 3.0.2

data/lib/active_record/relation/spawn_methods.rb

@@ -5,9 +5,11 @@ module ActiveRecord
     def merge(r)
       merged_relation = clone
       return merged_relation unless r
+      return to_a & r if r.is_a?(Array)
 
-      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) - [:joins, :where]).each do |method|
+      Relation::ASSOCIATION_METHODS.each do |method|
         value = r.send(:"#{method}_values")
+
         unless value.empty?
           if method == :includes
             merged_relation = merged_relation.includes(value)
@@ -17,26 +19,44 @@ module ActiveRecord
         end
       end
 
-      merged_relation = merged_relation.joins(r.joins_values)
-
-      merged_wheres = @where_values
+      (Relation::MULTI_VALUE_METHODS - [:joins, :where, :order]).each do |method|
+        value = r.send(:"#{method}_values")
+        merged_relation.send(:"#{method}_values=", merged_relation.send(:"#{method}_values") + value) if value.present?
+      end
 
-      r.where_values.each do |w|
-        if w.respond_to?(:operator) && w.operator == :==
-          merged_wheres = merged_wheres.reject { |p|
-            p.respond_to?(:operator) && p.operator == :== && p.operand1.name == w.operand1.name
-          }
+      order_value = r.order_values
+      if order_value.present?
+        if r.reorder_flag
+          merged_relation.order_values = order_value
+        else
+          merged_relation.order_values = merged_relation.order_values + order_value
         end
+      end
 
-        merged_wheres += [w]
+      merged_relation = merged_relation.joins(r.joins_values)
+
+      merged_wheres = @where_values + r.where_values
+
+      unless @where_values.empty?
+        # Remove duplicates, last one wins.
+        seen = Hash.new { |h,table| h[table] = {} }
+        merged_wheres = merged_wheres.reverse.reject { |w|
+          nuke = false
+          if w.respond_to?(:operator) && w.operator == :==
+            name              = w.left.name
+            table             = w.left.relation.name
+            nuke              = seen[table][name]
+            seen[table][name] = true
+          end
+          nuke
+        }.reverse
       end
 
       merged_relation.where_values = merged_wheres
 
       Relation::SINGLE_VALUE_METHODS.reject {|m| m == :lock}.each do |method|
-        unless (value = r.send(:"#{method}_value")).nil?
-          merged_relation.send(:"#{method}_value=", value)
-        end
+        value = r.send(:"#{method}_value")
+        merged_relation.send(:"#{method}_value=", value) unless value.nil?
       end
 
       merged_relation.lock_value = r.lock_value unless merged_relation.lock_value
@@ -52,12 +72,12 @@ module ActiveRecord
     def except(*skips)
       result = self.class.new(@klass, table)
 
-      (Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS).each do |method|
-        result.send(:"#{method}_values=", send(:"#{method}_values")) unless skips.include?(method)
+      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) - skips).each do |method|
+        result.send(:"#{method}_values=", send(:"#{method}_values"))
       end
 
-      Relation::SINGLE_VALUE_METHODS.each do |method|
-        result.send(:"#{method}_value=", send(:"#{method}_value")) unless skips.include?(method)
+      (Relation::SINGLE_VALUE_METHODS - skips).each do |method|
+        result.send(:"#{method}_value=", send(:"#{method}_value"))
       end
 
       result
@@ -66,14 +86,12 @@ module ActiveRecord
     def only(*onlies)
       result = self.class.new(@klass, table)
 
-      onlies.each do |only|
-        if (Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS).include?(only)
-          result.send(:"#{only}_values=", send(:"#{only}_values"))
-        elsif Relation::SINGLE_VALUE_METHODS.include?(only)
-          result.send(:"#{only}_value=", send(:"#{only}_value"))
-        else
-          raise "Invalid argument : #{only}"
-        end
+      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) & onlies).each do |method|
+        result.send(:"#{method}_values=", send(:"#{method}_values"))
+      end
+
+      (Relation::SINGLE_VALUE_METHODS & onlies).each do |method|
+        result.send(:"#{method}_value=", send(:"#{method}_value"))
       end
 
       result
@@ -87,23 +105,16 @@ module ActiveRecord
       return relation unless options
 
       options.assert_valid_keys(VALID_FIND_OPTIONS)
+      finders = options.dup
+      finders.delete_if { |key, value| value.nil? }
 
-      [:joins, :select, :group, :having, :limit, :offset, :from, :lock].each do |finder|
-        if value = options[finder]
-          relation = relation.send(finder, value)
-        end
-      end
-
-      relation = relation.readonly(options[:readonly]) if options.key? :readonly
-
-      # Give precedence to newly-applied orders and groups to play nicely with with_scope
-      [:group, :order].each do |finder|
-        relation.send("#{finder}_values=", Array.wrap(options[finder]) + relation.send("#{finder}_values")) if options.has_key?(finder)
+      ([:joins, :select, :group, :order, :having, :limit, :offset, :from, :lock, :readonly] & finders.keys).each do |finder|
+        relation = relation.send(finder, finders[finder])
       end
 
-      relation = relation.where(options[:conditions]) if options.has_key?(:conditions)
-      relation = relation.includes(options[:include]) if options.has_key?(:include)
-      relation = relation.extending(options[:extend]) if options.has_key?(:extend)
+      relation = relation.where(finders[:conditions]) if options.has_key?(:conditions)
+      relation = relation.includes(finders[:include]) if options.has_key?(:include)
+      relation = relation.extending(finders[:extend]) if options.has_key?(:extend)
 
       relation
     end

data/lib/active_record/serialization.rb

@@ -5,7 +5,7 @@ module ActiveRecord #:nodoc:
     include ActiveModel::Serializers::JSON
 
     def serializable_hash(options = nil)
-      options ||= {}
+      options = options.try(:clone) || {}
 
       options[:except] = Array.wrap(options[:except]).map { |n| n.to_s }
       options[:except] |= Array.wrap(self.class.inheritance_column)

data/lib/active_record/session_store.rb

@@ -228,7 +228,7 @@ module ActiveRecord
         @session_id     = attributes[:session_id]
         @data           = attributes[:data]
         @marshaled_data = attributes[:marshaled_data]
-        @new_record     = @marshaled_data.nil?
+        @persisted      = !@marshaled_data.nil?
       end
 
       # Lazy-unmarshal session state.
@@ -252,8 +252,8 @@ module ActiveRecord
         marshaled_data = self.class.marshal(data)
         connect        = connection
 
-        if @new_record
-          @new_record = false
+        unless @persisted
+          @persisted = true
           connect.update <<-end_sql, 'Create session'
             INSERT INTO #{table_name} (
               #{connect.quote_column_name(session_id_column)},
@@ -272,7 +272,7 @@ module ActiveRecord
       end
 
       def destroy
-        return if @new_record
+        return unless @persisted
 
         connect = connection
         connect.delete <<-end_sql, 'Destroy session'

data/lib/active_record/transactions.rb

@@ -242,7 +242,7 @@ module ActiveRecord
       with_transaction_returning_status { super }
     end
 
-    # Reset id and @new_record if the transaction rolls back.
+    # Reset id and @persisted if the transaction rolls back.
     def rollback_active_record_state!
       remember_transaction_record_state
       yield
@@ -297,9 +297,9 @@ module ActiveRecord
     # Save the new record state and id of a record so it can be restored later if a transaction fails.
     def remember_transaction_record_state #:nodoc
       @_start_transaction_state ||= {}
-      unless @_start_transaction_state.include?(:new_record)
+      unless @_start_transaction_state.include?(:persisted)
         @_start_transaction_state[:id] = id if has_attribute?(self.class.primary_key)
-        @_start_transaction_state[:new_record] = @new_record
+        @_start_transaction_state[:persisted] = @persisted
       end
       unless @_start_transaction_state.include?(:destroyed)
         @_start_transaction_state[:destroyed] = @destroyed
@@ -323,7 +323,7 @@ module ActiveRecord
           restore_state = remove_instance_variable(:@_start_transaction_state)
           if restore_state
             @attributes = @attributes.dup if @attributes.frozen?
-            @new_record = restore_state[:new_record]
+            @persisted = restore_state[:persisted]
             @destroyed = restore_state[:destroyed]
             if restore_state[:id]
               self.id = restore_state[:id]
@@ -345,11 +345,11 @@ module ActiveRecord
     def transaction_include_action?(action) #:nodoc
       case action
       when :create
-        transaction_record_state(:new_record)
+        transaction_record_state(:new_record) || !transaction_record_state(:persisted)
       when :destroy
         destroyed?
       when :update
-        !(transaction_record_state(:new_record) || destroyed?)
+        !(transaction_record_state(:new_record) || !transaction_record_state(:persisted) || destroyed?)
       end
     end
   end

data/lib/active_record/validations.rb

@@ -51,7 +51,7 @@ module ActiveRecord
 
     # Runs all the specified validations and returns true if no errors were added otherwise false.
     def valid?(context = nil)
-      context ||= (new_record? ? :create : :update)
+      context ||= (persisted? ? :update : :create)
       output = super(context)
 
       deprecated_callback_method(:validate)

data/lib/active_record/validations/uniqueness.rb

@@ -17,6 +17,11 @@ module ActiveRecord
         table = finder_class.unscoped
 
         table_name   = record.class.quoted_table_name
+
+        if value && record.class.serialized_attributes.key?(attribute.to_s)
+          value = YAML.dump value
+        end
+
         sql, params  = mount_sql_and_params(finder_class, table_name, attribute, value)
 
         relation = table.where(sql, *params)
@@ -26,7 +31,7 @@ module ActiveRecord
           relation = relation.where(scope_item => scope_value)
         end
 
-        unless record.new_record?
+        if record.persisted?
           # TODO : This should be in Arel
           relation = relation.where("#{record.class.quoted_table_name}.#{record.class.primary_key} <> ?", record.send(:id))
         end

data/lib/active_record/version.rb

@@ -2,8 +2,8 @@ module ActiveRecord
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 0
-    TINY  = 0
-
+    TINY  = 1
+        
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

data/lib/rails/generators/active_record.rb

@@ -1,27 +1,19 @@
 require 'rails/generators/named_base'
 require 'rails/generators/migration'
 require 'rails/generators/active_model'
+require 'rails/generators/active_record/migration'
 require 'active_record'
 
 module ActiveRecord
   module Generators
     class Base < Rails::Generators::NamedBase #:nodoc:
       include Rails::Generators::Migration
+      extend ActiveRecord::Generators::Migration
 
       # Set the current directory as base for the inherited generators.
       def self.base_root
         File.dirname(__FILE__)
       end
-
-      # Implement the required interface for Rails::Generators::Migration.
-      def self.next_migration_number(dirname) #:nodoc:
-        next_migration_number = current_migration_number(dirname) + 1
-        if ActiveRecord::Base.timestamped_migrations
-          [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % next_migration_number].max
-        else
-          "%.3d" % next_migration_number
-        end
-      end
     end
   end
 end

data/lib/rails/generators/active_record/migration.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module Generators
+    module Migration
+      # Implement the required interface for Rails::Generators::Migration.
+      def next_migration_number(dirname) #:nodoc:
+        next_migration_number = current_migration_number(dirname) + 1
+        if ActiveRecord::Base.timestamped_migrations
+          [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % next_migration_number].max
+        else
+          "%.3d" % next_migration_number
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 3
   prerelease: false
   segments: 
   - 3
   - 0
-  - 0
-  version: 3.0.0
+  - 2
+  version: 3.0.2
 platform: ruby
 authors: 
 - David Heinemeier Hansson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-29 00:00:00 -05:00
+date: 2010-11-15 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,12 +26,12 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 3
         segments: 
         - 3
         - 0
-        - 0
-        version: 3.0.0
+        - 2
+        version: 3.0.2
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -42,12 +42,12 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 3
         segments: 
         - 3
         - 0
-        - 0
-        version: 3.0.0
+        - 2
+        version: 3.0.2
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -58,12 +58,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 23
+        hash: 11
         segments: 
-        - 1
-        - 0
+        - 2
         - 0
-        version: 1.0.0
+        - 2
+        version: 2.0.2
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -174,6 +174,7 @@ files:
 - lib/active_record.rb
 - lib/rails/generators/active_record/migration/migration_generator.rb
 - lib/rails/generators/active_record/migration/templates/migration.rb
+- lib/rails/generators/active_record/migration.rb
 - lib/rails/generators/active_record/model/model_generator.rb
 - lib/rails/generators/active_record/model/templates/migration.rb
 - lib/rails/generators/active_record/model/templates/model.rb