activerecord 4.0.0.beta1 → 4.0.0.rc1

data/lib/active_record/attribute_methods/dirty.rb

@@ -107,7 +107,11 @@ module ActiveRecord
 
       def changes_from_zero_to_string?(old, value)
         # For columns with old 0 and value non-empty string
-        old == 0 && value.is_a?(String) && value.present? && value != '0'
+        old == 0 && value.is_a?(String) && value.present? && non_zero?(value)
+      end
+
+      def non_zero?(value)
+        value !~ /\A0+(\.0+)?\z/
       end
     end
   end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -90,7 +90,7 @@ module ActiveRecord
             base_name.foreign_key
           else
             if ActiveRecord::Base != self && table_exists?
-              connection.schema_cache.primary_keys[table_name]
+              connection.schema_cache.primary_keys(table_name)
             else
               'id'
             end

data/lib/active_record/attribute_methods/serialization.rb

@@ -11,6 +11,12 @@ module ActiveRecord
       end
 
       module ClassMethods
+        ##
+        # :method: serialized_attributes
+        #
+        # Returns a hash of all the attributes that have been specified for
+        # serialization as keys and their class restriction as values.
+
         # If you have an attribute that needs to be saved to the database as an
         # object, and retrieved as the same object, then specify the name of that
         # attribute using this method and it will be handled automatically. The
@@ -44,6 +50,7 @@ module ActiveRecord
         end
       end
 
+      # *DEPRECATED*: Use ActiveRecord::AttributeMethods::Serialization::ClassMethods#serialized_attributes class level method instead.
       def serialized_attributes
         message = "Instance level serialized_attributes method is deprecated, please use class level method."
         ActiveSupport::Deprecation.warn message
@@ -86,10 +93,10 @@ module ActiveRecord
 
       # This is only added to the model when serialize is called, which
       # ensures we do not make things slower when serialization is not used.
-      module Behavior #:nodoc:
+      module Behavior # :nodoc:
         extend ActiveSupport::Concern
 
-        module ClassMethods
+        module ClassMethods # :nodoc:
           def initialize_attributes(attributes, options = {})
             serialized = (options.delete(:serialized) { true }) ? :serialized : :unserialized
             super(attributes, options)

data/lib/active_record/autosave_association.rb

@@ -62,14 +62,14 @@ module ActiveRecord
   # Note that the model is _not_ yet removed from the database:
   #
   #   id = post.author.id
-  #   Author.find_by_id(id).nil? # => false
+  #   Author.find_by(id: id).nil? # => false
   #
   #   post.save
   #   post.reload.author # => nil
   #
   # Now it _is_ removed from the database:
   #
-  #   Author.find_by_id(id).nil? # => true
+  #   Author.find_by(id: id).nil? # => true
   #
   # === One-to-many Example
   #
@@ -113,14 +113,14 @@ module ActiveRecord
   # Note that the model is _not_ yet removed from the database:
   #
   #   id = post.comments.last.id
-  #   Comment.find_by_id(id).nil? # => false
+  #   Comment.find_by(id: id).nil? # => false
   #
   #   post.save
   #   post.reload.comments.length # => 1
   #
   # Now it _is_ removed from the database:
   #
-  #   Comment.find_by_id(id).nil? # => true
+  #   Comment.find_by(id: id).nil? # => true
 
   module AutosaveAssociation
     extend ActiveSupport::Concern
@@ -212,6 +212,7 @@ module ActiveRecord
     # Reloads the attributes of the object as usual and clears <tt>marked_for_destruction</tt> flag.
     def reload(options = nil)
       @marked_for_destruction = false
+      @destroyed_by_association = nil
       super
     end
 
@@ -231,6 +232,19 @@ module ActiveRecord
       @marked_for_destruction
     end
 
+    # Records the association that is being destroyed and destroying this
+    # record in the process.
+    def destroyed_by_association=(reflection)
+      @destroyed_by_association = reflection
+    end
+
+    # Returns the association for the parent being destroyed.
+    #
+    # Used to avoid updating the counter cache unnecessarily.
+    def destroyed_by_association
+      @destroyed_by_association
+    end
+
     # Returns whether or not this record has been changed in any way (including whether
     # any of its nested autosave associations are likewise changed)
     def changed_for_autosave?
@@ -347,7 +361,7 @@ module ActiveRecord
         end
 
         # reconstruct the scope now that we know the owner's id
-        association.send(:reset_scope) if association.respond_to?(:reset_scope)
+        association.reset_scope if association.respond_to?(:reset_scope)
       end
     end
 

data/lib/active_record/base.rb

@@ -160,10 +160,10 @@ module ActiveRecord #:nodoc:
   #
   # == Dynamic attribute-based finders
   #
-  # Dynamic attribute-based finders are a cleaner way of getting (and/or creating) objects
+  # Dynamic attribute-based finders are a mildly deprecated way of getting (and/or creating) objects
   # by simple queries without turning to SQL. They work by appending the name of an attribute
   # to <tt>find_by_</tt> like <tt>Person.find_by_user_name</tt>.
-  # Instead of writing <tt>Person.where(user_name: user_name).first</tt>, you just do
+  # Instead of writing <tt>Person.find_by(user_name: user_name)</tt>, you can use
   # <tt>Person.find_by_user_name(user_name)</tt>.
   #
   # It's possible to add an exclamation point (!) on the end of the dynamic finders to get them to raise an
@@ -172,7 +172,7 @@ module ActiveRecord #:nodoc:
   #
   # It's also possible to use multiple attributes in the same find by separating them with "_and_".
   #
-  #  Person.where(user_name: user_name, password: password).first
+  #  Person.find_by(user_name: user_name, password: password)
   #  Person.find_by_user_name_and_password(user_name, password) # with dynamic finder
   #
   # It's even possible to call these dynamic finder methods on relations and named scopes.

data/lib/active_record/callbacks.rb

@@ -83,7 +83,7 @@ module ActiveRecord
   #
   # In that case, <tt>Reply#destroy</tt> would only run +destroy_readers+ and _not_ +destroy_author+.
   # So, use the callback macros when you want to ensure that a certain callback is called for the entire
-  # hierarchy, and use the regular overwriteable methods when you want to leave it up to each descendant
+  # hierarchy, and use the regular overwritable methods when you want to leave it up to each descendant
   # to decide whether they want to call +super+ and trigger the inherited callbacks.
   #
   # *IMPORTANT:* In order for inheritance to work for the callback queues, you must specify the

data/lib/active_record/coders/yaml_column.rb

@@ -3,7 +3,6 @@ require 'yaml'
 module ActiveRecord
   module Coders # :nodoc:
     class YAMLColumn # :nodoc:
-      RESCUE_ERRORS = [ ArgumentError, Psych::SyntaxError ]
 
       attr_accessor :object_class
 
@@ -24,19 +23,15 @@ module ActiveRecord
       def load(yaml)
         return object_class.new if object_class != Object && yaml.nil?
         return yaml unless yaml.is_a?(String) && yaml =~ /^---/
-        begin
-          obj = YAML.load(yaml)
-
-          unless obj.is_a?(object_class) || obj.nil?
-            raise SerializationTypeMismatch,
-              "Attribute was supposed to be a #{object_class}, but was a #{obj.class}"
-          end
-          obj ||= object_class.new if object_class != Object
-
-          obj
-        rescue *RESCUE_ERRORS
-          yaml
+        obj = YAML.load(yaml)
+
+        unless obj.is_a?(object_class) || obj.nil?
+          raise SerializationTypeMismatch,
+            "Attribute was supposed to be a #{object_class}, but was a #{obj.class}"
         end
+        obj ||= object_class.new if object_class != Object
+
+        obj
       end
     end
   end

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -253,14 +253,6 @@ module ActiveRecord
         @available = Queue.new self
       end
 
-      # Hack for tests to be able to add connections.  Do not call outside of tests
-      def insert_connection_for_test!(c) #:nodoc:
-        synchronize do
-          @connections << c
-          @available.add c
-        end
-      end
-
       # Retrieve the connection associated with the current thread, or call
       # #checkout to obtain one if necessary.
       #
@@ -406,7 +398,9 @@ module ActiveRecord
         synchronize do
           stale = Time.now - @dead_connection_timeout
           connections.dup.each do |conn|
-            remove conn if conn.in_use? && stale > conn.last_use && !conn.active?
+            if conn.in_use? && stale > conn.last_use && !conn.active?
+              remove conn
+            end
           end
         end
       end

data/lib/active_record/connection_adapters/abstract/database_limits.rb

@@ -21,7 +21,7 @@ module ActiveRecord
       # limit is enforced by rails and Is less than or equal to
       # <tt>index_name_length</tt>. The gap between
       # <tt>index_name_length</tt> is to allow internal rails
-      # opreations to use prefixes in temporary opreations.
+      # operations to use prefixes in temporary operations.
       def allowed_index_name_length
         index_name_length
       end

data/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -125,7 +125,8 @@ module ActiveRecord
       # In order to get around this problem, #transaction will emulate the effect
       # of nested transactions, by using savepoints:
       # http://dev.mysql.com/doc/refman/5.0/en/savepoint.html
-      # Savepoints are supported by MySQL and PostgreSQL, but not SQLite3.
+      # Savepoints are supported by MySQL and PostgreSQL. SQLite3 version >= '3.6.8'
+      # supports savepoints.
       #
       # It is safe to call this method if a database transaction is already open,
       # i.e. if #transaction is called within another #transaction block. In case

data/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -25,19 +25,13 @@ module ActiveRecord
         when true, false
           if column && column.type == :integer
             value ? '1' : '0'
-          elsif column && [:text, :string, :binary].include?(column.type)
-            value ? "'1'" : "'0'"
           else
             value ? quoted_true : quoted_false
           end
           # BigDecimals need to be put in a non-normalized form and quoted.
         when nil        then "NULL"
-        when Numeric, ActiveSupport::Duration
-          value = BigDecimal === value ? value.to_s('F') : value.to_s
-          if column && ![:integer, :float, :decimal].include?(column.type)
-            value = "'#{value}'"
-          end
-          value
+        when BigDecimal then value.to_s('F')
+        when Numeric, ActiveSupport::Duration then value.to_s
         when Date, Time then "'#{quoted_date(value)}'"
         when Symbol     then "'#{quote_string(value.to_s)}'"
         when Class      then "'#{value.to_s}'"

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -8,44 +8,28 @@ module ActiveRecord
     # Abstract representation of an index definition on a table. Instances of
     # this type are typically created and returned by methods in database
     # adapters. e.g. ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter#indexes
-    class IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths, :orders, :where) #:nodoc:
+    class IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths, :orders, :where, :type, :using) #:nodoc:
     end
 
     # Abstract representation of a column definition. Instances of this type
     # are typically created by methods in TableDefinition, and added to the
     # +columns+ attribute of said TableDefinition object, in order to be used
     # for generating a number of table creation or table changing SQL statements.
-    class ColumnDefinition < Struct.new(:base, :name, :type, :limit, :precision, :scale, :default, :null) #:nodoc:
-
+    class ColumnDefinition < Struct.new(:name, :type, :limit, :precision, :scale, :default, :null, :first, :after, :primary_key) #:nodoc:
       def string_to_binary(value)
         value
       end
 
-      def sql_type
-        base.type_to_sql(type.to_sym, limit, precision, scale)
-      end
-
-      def to_sql
-        column_sql = "#{base.quote_column_name(name)} #{sql_type}"
-        column_options = {}
-        column_options[:null] = null unless null.nil?
-        column_options[:default] = default unless default.nil?
-        add_column_options!(column_sql, column_options) unless type.to_sym == :primary_key
-        column_sql
+      def primary_key?
+        primary_key || type.to_sym == :primary_key
       end
-
-      private
-
-        def add_column_options!(sql, options)
-          base.add_column_options!(sql, options.merge(:column => self))
-        end
     end
 
     # Represents the schema of an SQL table in an abstract way. This class
     # provides methods for manipulating the schema representation.
     #
-    # Inside migration files, the +t+ object in +create_table+ and
-    # +change_table+ is actually of this type:
+    # Inside migration files, the +t+ object in +create_table+
+    # is actually of this type:
     #
     #   class SomeMigration < ActiveRecord::Migration
     #     def up
@@ -64,28 +48,25 @@ module ActiveRecord
     class TableDefinition
       # An array of ColumnDefinition objects, representing the column changes
       # that have been defined.
-      attr_accessor :columns, :indexes
+      attr_accessor :indexes
+      attr_reader :name, :temporary, :options
 
-      def initialize(base)
-        @columns = []
+      def initialize(types, name, temporary, options)
         @columns_hash = {}
         @indexes = {}
-        @base = base
+        @native = types
+        @temporary = temporary
+        @options = options
+        @name = name
       end
 
-      def xml(*args)
-        raise NotImplementedError unless %w{
-          sqlite mysql mysql2
-        }.include? @base.adapter_name.downcase
-
-        options = args.extract_options!
-        column(args[0], :text, options)
-      end
+      def columns; @columns_hash.values; end
 
       # Appends a primary key definition to the table definition.
       # Can be called multiple times, but this is probably not a good idea.
-      def primary_key(name)
-        column(name, :primary_key)
+      def primary_key(name, type = :primary_key, options = {})
+        options[:primary_key] = true
+        column(name, type, options)
       end
 
       # Returns a ColumnDefinition for the column with name +name+.
@@ -238,20 +219,14 @@ module ActiveRecord
           raise ArgumentError, "you can't redefine the primary key column '#{name}'. To define a custom primary key, pass { id: false } to create_table."
         end
 
-        column = self[name] || new_column_definition(@base, name, type)
-
-        limit = options.fetch(:limit) do
-          native[type][:limit] if native[type].is_a?(Hash)
-        end
-
-        column.limit     = limit
-        column.precision = options[:precision]
-        column.scale     = options[:scale]
-        column.default   = options[:default]
-        column.null      = options[:null]
+        @columns_hash[name] = new_column_definition(name, type, options)
         self
       end
 
+      def remove_column(name)
+        @columns_hash.delete name.to_s
+      end
+
       [:string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time, :date, :binary, :boolean].each do |column_type|
         define_method column_type do |*args|
           options = args.extract_options!
@@ -283,33 +258,57 @@ module ActiveRecord
         args.each do |col|
           column("#{col}_id", :integer, options)
           column("#{col}_type", :string, polymorphic.is_a?(Hash) ? polymorphic : options) if polymorphic
-          index(polymorphic ? %w(id type).map { |t| "#{col}_#{t}" } : "#{col}_id", index_options.is_a?(Hash) ? index_options : nil) if index_options
+          index(polymorphic ? %w(id type).map { |t| "#{col}_#{t}" } : "#{col}_id", index_options.is_a?(Hash) ? index_options : {}) if index_options
         end
       end
       alias :belongs_to :references
 
-      # Returns a String whose contents are the column definitions
-      # concatenated together. This string can then be prepended and appended to
-      # to generate the final SQL to create the table.
-      def to_sql
-        @columns.map { |c| c.to_sql } * ', '
+      def new_column_definition(name, type, options) # :nodoc:
+        column = create_column_definition name, type
+        limit = options.fetch(:limit) do
+          native[type][:limit] if native[type].is_a?(Hash)
+        end
+
+        column.limit       = limit
+        column.precision   = options[:precision]
+        column.scale       = options[:scale]
+        column.default     = options[:default]
+        column.null        = options[:null]
+        column.first       = options[:first]
+        column.after       = options[:after]
+        column.primary_key = type == :primary_key || options[:primary_key]
+        column
       end
 
       private
-      def new_column_definition(base, name, type)
-        definition = ColumnDefinition.new base, name, type
-        @columns << definition
-        @columns_hash[name] = definition
-        definition
+      def create_column_definition(name, type)
+        ColumnDefinition.new name, type
       end
 
       def primary_key_column_name
-        primary_key_column = columns.detect { |c| c.type == :primary_key }
+        primary_key_column = columns.detect { |c| c.primary_key? }
         primary_key_column && primary_key_column.name
       end
 
       def native
-        @base.native_database_types
+        @native
+      end
+    end
+
+    class AlterTable # :nodoc:
+      attr_reader :adds
+
+      def initialize(td)
+        @td   = td
+        @adds = []
+      end
+
+      def name; @td.name; end
+
+      def add_column(name, type, options)
+        name = name.to_s
+        type = type.to_sym
+        @adds << @td.new_column_definition(name, type, options)
       end
     end
 
@@ -489,7 +488,7 @@ module ActiveRecord
           args.each do |name|
             @base.add_column(@table_name, name, column_type, options)
           end
-        end  
+        end
       end
 
       private