activerecord 4.2.2 → 4.2.3.rc1

data/lib/active_record/relation/delegation.rb

@@ -40,7 +40,7 @@ module ActiveRecord
     BLACKLISTED_ARRAY_METHODS = [
       :compact!, :flatten!, :reject!, :reverse!, :rotate!, :map!,
       :shuffle!, :slice!, :sort!, :sort_by!, :delete_if,
-      :keep_if, :pop, :shift, :delete_at, :compact, :select!
+      :keep_if, :pop, :shift, :delete_at, :select!
     ].to_set # :nodoc:
 
     delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to_ary, :join, to: :to_a

data/lib/active_record/relation/finder_methods.rb

@@ -114,23 +114,11 @@ module ActiveRecord
     # Find the first record (or first N records if a parameter is supplied).
     # If no order is defined it will order by primary key.
     #
-    #   Person.first # returns the first object fetched by SELECT * FROM people
+    #   Person.first # returns the first object fetched by SELECT * FROM people ORDER BY people.id LIMIT 1
     #   Person.where(["user_name = ?", user_name]).first
     #   Person.where(["user_name = :u", { u: user_name }]).first
     #   Person.order("created_on DESC").offset(5).first
-    #   Person.first(3) # returns the first three objects fetched by SELECT * FROM people LIMIT 3
-    #
-    # ==== Rails 3
-    #
-    #   Person.first # SELECT "people".* FROM "people" LIMIT 1
-    #
-    # NOTE: Rails 3 may not order this query by the primary key and the order
-    # will depend on the database implementation. In order to ensure that behavior,
-    # use <tt>User.order(:id).first</tt> instead.
-    #
-    # ==== Rails 4
-    #
-    #   Person.first # SELECT "people".* FROM "people" ORDER BY "people"."id" ASC LIMIT 1
+    #   Person.first(3) # returns the first three objects fetched by SELECT * FROM people ORDER BY people.id LIMIT 3
     #
     def first(limit = nil)
       if limit
@@ -379,7 +367,7 @@ module ActiveRecord
     def construct_relation_for_association_calculations
       from = arel.froms.first
       if Arel::Table === from
-        apply_join_dependency(self, construct_join_dependency)
+        apply_join_dependency(self, construct_join_dependency(joins_values))
       else
         # FIXME: as far as I can tell, `from` will always be an Arel::Table.
         # There are no tests that test this branch, but presumably it's

data/lib/active_record/relation/predicate_builder.rb

@@ -6,7 +6,9 @@ module ActiveRecord
     autoload :ArrayHandler, 'active_record/relation/predicate_builder/array_handler'
 
     def self.resolve_column_aliases(klass, hash)
-      hash = hash.dup
+      # This method is a hot spot, so for now, use Hash[] to dup the hash.
+      #   https://bugs.ruby-lang.org/issues/7166
+      hash = Hash[hash]
       hash.keys.grep(Symbol) do |key|
         if klass.attribute_alias? key
           hash[klass.attribute_alias(key)] = hash.delete key
@@ -112,7 +114,8 @@ module ActiveRecord
       @handlers.unshift([klass, handler])
     end
 
-    register_handler(BasicObject, ->(attribute, value) { attribute.eq(value) })
+    BASIC_OBJECT_HANDLER = ->(attribute, value) { attribute.eq(value) } # :nodoc:
+    register_handler(BasicObject, BASIC_OBJECT_HANDLER)
     # FIXME: I think we need to deprecate this behavior
     register_handler(Class, ->(attribute, value) { attribute.eq(value.name) })
     register_handler(Base, ->(attribute, value) { attribute.eq(value.id) })
@@ -142,5 +145,11 @@ module ActiveRecord
         value
       end
     end
+
+    def self.can_be_bound?(value) # :nodoc:
+      !value.nil? &&
+        !value.is_a?(Hash) &&
+        handler_for(value) == BASIC_OBJECT_HANDLER
+    end
   end
 end

data/lib/active_record/relation/query_methods.rb

@@ -909,7 +909,7 @@ module ActiveRecord
 
       where_values.reject! do |rel|
         case rel
-        when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThanOrEqual
+        when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
           subrelation = (rel.left.kind_of?(Arel::Attributes::Attribute) ? rel.left : rel.right)
           subrelation.name == target_value
         end
@@ -965,12 +965,9 @@ module ActiveRecord
 
     def create_binds(opts)
       bindable, non_binds = opts.partition do |column, value|
-        case value
-        when String, Integer, ActiveRecord::StatementCache::Substitute
-          @klass.columns_hash.include? column.to_s
-        else
-          false
-        end
+        PredicateBuilder.can_be_bound?(value) &&
+          @klass.columns_hash.include?(column.to_s) &&
+          !@klass.reflect_on_aggregation(column)
       end
 
       association_binds, non_binds = non_binds.partition do |column, value|
@@ -980,6 +977,8 @@ module ActiveRecord
       new_opts = {}
       binds = []
 
+      connection = self.connection
+
       bindable.each do |(column,value)|
         binds.push [@klass.columns_hash[column.to_s], value]
         new_opts[column] = connection.substitute_at(column)
@@ -1064,15 +1063,13 @@ module ActiveRecord
     end
 
     def arel_columns(columns)
-      if from_value
-        columns
-      else
-        columns.map do |field|
-          if (Symbol === field || String === field) && columns_hash.key?(field.to_s)
-            arel_table[field]
-          else
-            field
-          end
+      columns.map do |field|
+        if (Symbol === field || String === field) && columns_hash.key?(field.to_s) && !from_value
+          arel_table[field]
+        elsif Symbol === field
+          connection.quote_table_name(field.to_s)
+        else
+          field
         end
       end
     end

data/lib/active_record/tasks/database_tasks.rb

@@ -197,7 +197,7 @@ module ActiveRecord
         load_schema_current(format, file)
       end
 
-      def schema_file(format = ActiveSupport::Base.schema_format)
+      def schema_file(format = ActiveRecord::Base.schema_format)
         case format
         when :ruby
           File.join(db_dir, "schema.rb")

data/lib/active_record/transactions.rb

@@ -311,7 +311,7 @@ module ActiveRecord
     # Ensure that it is not called if the object was never persisted (failed create),
     # but call it after the commit of a destroyed object.
     def committed!(should_run_callbacks = true) #:nodoc:
-      _run_commit_callbacks if should_run_callbacks && destroyed? || persisted?
+      run_callbacks(:commit) if should_run_callbacks && destroyed? || persisted?
     ensure
       force_clear_transaction_record_state
     end
@@ -319,7 +319,7 @@ module ActiveRecord
     # Call the +after_rollback+ callbacks. The +force_restore_state+ argument indicates if the record
     # state should be rolled back to the beginning or just to the last savepoint.
     def rolledback!(force_restore_state = false, should_run_callbacks = true) #:nodoc:
-      _run_rollback_callbacks if should_run_callbacks
+      run_callbacks(:rollback) if should_run_callbacks
     ensure
       restore_transaction_record_state(force_restore_state)
       clear_transaction_record_state
@@ -328,9 +328,13 @@ module ActiveRecord
     # Add the record to the current transaction so that the +after_rollback+ and +after_commit+ callbacks
     # can be called.
     def add_to_transaction
-      if self.class.connection.add_transaction_record(self)
-        remember_transaction_record_state
+      if has_transactional_callbacks?
+        self.class.connection.add_transaction_record(self)
+      else
+        sync_with_transaction_state
+        set_transaction_state(self.class.connection.transaction_state)
       end
+      remember_transaction_record_state
     end
 
     # Executes +method+ within a transaction and captures its return value as a
@@ -385,10 +389,14 @@ module ActiveRecord
         transaction_level = (@_start_transaction_state[:level] || 0) - 1
         if transaction_level < 1 || force
           restore_state = @_start_transaction_state
-          thaw unless restore_state[:frozen?]
+          thaw
           @new_record = restore_state[:new_record]
           @destroyed  = restore_state[:destroyed]
-          write_attribute(self.class.primary_key, restore_state[:id]) if self.class.primary_key
+          pk = self.class.primary_key
+          if pk && read_attribute(pk) != restore_state[:id]
+            write_attribute(pk, restore_state[:id])
+          end
+          freeze if restore_state[:frozen?]
         end
       end
     end

data/lib/active_record/type/boolean.rb

@@ -16,6 +16,7 @@ module ActiveRecord
           if !ConnectionAdapters::Column::FALSE_VALUES.include?(value)
             ActiveSupport::Deprecation.warn(<<-MSG.squish)
               You attempted to assign a value which is not explicitly `true` or `false`
+              (#{value.inspect})
               to a boolean column. Currently this value casts to `false`. This will
               change to match Ruby's semantics, and will cast to `true` in Rails 5.
               If you would like to maintain the current behavior, you should

data/lib/active_record/type/hash_lookup_type_map.rb

@@ -1,12 +1,18 @@
 module ActiveRecord
   module Type
     class HashLookupTypeMap < TypeMap # :nodoc:
-      delegate :key?, to: :@mapping
-
       def alias_type(type, alias_type)
         register_type(type) { |_, *args| lookup(alias_type, *args) }
       end
 
+      def key?(key)
+        @mapping.key?(key)
+      end
+
+      def keys
+        @mapping.keys
+      end
+
       private
 
       def perform_fetch(type, *args, &block)

data/lib/active_record/type/serialized.rb

@@ -27,9 +27,15 @@ module ActiveRecord
         end
       end
 
+      def inspect
+        Kernel.instance_method(:inspect).bind(self).call
+      end
+
       def changed_in_place?(raw_old_value, value)
         return false if value.nil?
-        subtype.changed_in_place?(raw_old_value, type_cast_for_database(value))
+        raw_new_value = type_cast_for_database(value)
+        raw_old_value.nil? != raw_new_value.nil? ||
+          subtype.changed_in_place?(raw_old_value, raw_new_value)
       end
 
       def accessor

data/lib/active_record/validations/uniqueness.rb

@@ -15,11 +15,15 @@ module ActiveRecord
         table = finder_class.arel_table
         value = map_enum_attribute(finder_class, attribute, value)
 
-        relation = build_relation(finder_class, table, attribute, value)
-        relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.id)) if record.persisted?
-        relation = scope_relation(record, table, relation)
-        relation = finder_class.unscoped.where(relation)
-        relation = relation.merge(options[:conditions]) if options[:conditions]
+        begin
+          relation = build_relation(finder_class, table, attribute, value)
+          relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.id)) if record.persisted?
+          relation = scope_relation(record, table, relation)
+          relation = finder_class.unscoped.where(relation)
+          relation = relation.merge(options[:conditions]) if options[:conditions]
+        rescue RangeError
+          relation = finder_class.none
+        end
 
         if relation.exists?
           error_options = options.except(:case_sensitive, :scope, :conditions)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord
 version: !ruby/object:Gem::Version
-  version: 4.2.2
+  version: 4.2.3.rc1
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-16 00:00:00.000000000 Z
+date: 2015-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.2.2
+        version: 4.2.3.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.2.2
+        version: 4.2.3.rc1
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.2.2
+        version: 4.2.3.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.2.2
+        version: 4.2.3.rc1
 - !ruby/object:Gem::Dependency
   name: arel
   requirement: !ruby/object:Gem::Requirement
@@ -298,9 +298,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.5