activerecord 4.2.4 → 4.2.10

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -245,7 +245,7 @@ module ActiveRecord
         return @client_encoding if @client_encoding
 
         result = exec_query(
-          "SHOW VARIABLES WHERE Variable_name = 'character_set_client'",
+          "select @@character_set_client",
           'SCHEMA')
         @client_encoding = ENCODINGS[result.rows.last.last]
       end
@@ -282,6 +282,10 @@ module ActiveRecord
               super
             end
           end
+
+          def has_precision?
+            precision || 0
+          end
         end
 
         class Time < Type::Time # :nodoc:
@@ -328,8 +332,11 @@ module ActiveRecord
 
       def initialize_type_map(m) # :nodoc:
         super
-        m.register_type %r(datetime)i, Fields::DateTime.new
         m.register_type %r(time)i,     Fields::Time.new
+        m.register_type(%r(datetime)i) do |sql_type|
+          precision = extract_precision(sql_type)
+          Fields::DateTime.new(precision: precision)
+        end
       end
 
       def exec_without_stmt(sql, name = 'SQL') # :nodoc:

data/lib/active_record/connection_adapters/postgresql/oid/array.rb

@@ -80,6 +80,7 @@ module ActiveRecord
                 value
               end
             when nil then "NULL"
+            when ::Date, ::DateTime, ::Time then subtype.type_cast_for_schema(value)
             else value
             end
           end

data/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb

@@ -36,7 +36,7 @@ module ActiveRecord
               WHERE
                 t.typname IN (%s)
                 OR t.typtype IN (%s)
-                OR t.typinput::varchar = 'array_in'
+                OR t.typinput = 'array_in(cstring,oid,integer)'::regprocedure
                 OR t.typelem != 0
             SQL
           end

data/lib/active_record/connection_adapters/postgresql/schema_statements.rb

@@ -86,7 +86,7 @@ module ActiveRecord
           execute "DROP DATABASE IF EXISTS #{quote_table_name(name)}"
         end
 
-        # Returns the list of all tables in the schema search path or a specified schema.
+        # Returns the list of all tables in the schema search path.
         def tables(name = nil)
           query(<<-SQL, 'SCHEMA').map { |row| row[0] }
             SELECT tablename
@@ -95,6 +95,16 @@ module ActiveRecord
           SQL
         end
 
+        def data_sources # :nodoc
+          select_values(<<-SQL, 'SCHEMA')
+            SELECT c.relname
+            FROM pg_class c
+            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relkind IN ('r', 'v','m') -- (r)elation/table, (v)iew, (m)aterialized view
+            AND n.nspname = ANY (current_schemas(false))
+          SQL
+        end
+
         # Returns true if table exists.
         # If the schema is not specified as part of +name+ then it will only find tables within
         # the current schema search path (regardless of permissions to access tables in other schemas)
@@ -111,6 +121,7 @@ module ActiveRecord
               AND n.nspname = #{name.schema ? "'#{name.schema}'" : 'ANY (current_schemas(false))'}
           SQL
         end
+        alias data_source_exists? table_exists?
 
         def drop_table(table_name, options = {})
           execute "DROP TABLE #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
@@ -552,7 +563,7 @@ module ActiveRecord
               when 1, 2; 'smallint'
               when 3, 4; 'integer'
               when 5..8; 'bigint'
-              else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
+              else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with scale 0 instead.")
             end
           when 'datetime'
             return super unless precision

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -308,12 +308,8 @@ module ActiveRecord
         true
       end
 
-      # Enable standard-conforming strings if available.
       def set_standard_conforming_strings
-        old, self.client_min_messages = client_min_messages, 'panic'
-        execute('SET standard_conforming_strings = on', 'SCHEMA') rescue nil
-      ensure
-        self.client_min_messages = old
+        execute('SET standard_conforming_strings = on', 'SCHEMA')
       end
 
       def supports_ddl_transactions?
@@ -677,7 +673,7 @@ module ActiveRecord
           self.client_min_messages = @config[:min_messages] || 'warning'
           self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]
 
-          # Use standard-conforming strings if available so we don't have to do the E'...' dance.
+          # Use standard-conforming strings so we don't have to do the E'...' dance.
           set_standard_conforming_strings
 
           # If using Active Record's time zone support configure the connection to return

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -74,18 +74,6 @@ module ActiveRecord
         boolean:      { name: "boolean" }
       }
 
-      class Version
-        include Comparable
-
-        def initialize(version_string)
-          @version = version_string.split('.').map { |v| v.to_i }
-        end
-
-        def <=>(version_string)
-          @version <=> version_string.split('.').map { |v| v.to_i }
-        end
-      end
-
       class StatementPool < ConnectionAdapters::StatementPool
         def initialize(connection, max)
           super
@@ -375,10 +363,12 @@ module ActiveRecord
           row['name']
         end
       end
+      alias data_sources tables
 
       def table_exists?(table_name)
         table_name && tables(nil, table_name).any?
       end
+      alias data_source_exists? table_exists?
 
       # Returns an array of +Column+ objects for the table specified by +table_name+.
       def columns(table_name) #:nodoc:

data/lib/active_record/core.rb

@@ -299,6 +299,7 @@ module ActiveRecord
     #   post.init_with(coder)
     #   post.title # => 'hello world'
     def init_with(coder)
+      coder = LegacyYamlAdapter.convert(self.class, coder)
       @attributes = coder['attributes']
 
       init_internals
@@ -372,6 +373,7 @@ module ActiveRecord
       coder['raw_attributes'] = attributes_before_type_cast
       coder['attributes'] = @attributes
       coder['new_record'] = new_record?
+      coder['active_record_yaml_version'] = 0
     end
 
     # Returns true if +comparison_object+ is the same exact object, or +comparison_object+

data/lib/active_record/enum.rb

@@ -18,10 +18,9 @@ module ActiveRecord
   #   conversation.archived? # => true
   #   conversation.status    # => "archived"
   #
-  #   # conversation.update! status: 1
+  #   # conversation.status = 1
   #   conversation.status = "archived"
   #
-  #   # conversation.update! status: nil
   #   conversation.status = nil
   #   conversation.status.nil? # => true
   #   conversation.status      # => nil
@@ -70,7 +69,7 @@ module ActiveRecord
   # Where conditions on an enum attribute must use the ordinal value of an enum.
   module Enum
     def self.extended(base) # :nodoc:
-      base.class_attribute(:defined_enums)
+      base.class_attribute(:defined_enums, instance_writer: false)
       base.defined_enums = {}
     end
 

data/lib/active_record/errors.rb

@@ -219,11 +219,12 @@ module ActiveRecord
   class UnknownPrimaryKey < ActiveRecordError
     attr_reader :model
 
-    def initialize(model)
-      super("Unknown primary key for table #{model.table_name} in model #{model}.")
+    def initialize(model, description = nil)
+      message = "Unknown primary key for table #{model.table_name} in model #{model}."
+      message += "\n#{description}" if description
+      super(message)
       @model = model
     end
-
   end
 
   # Raised when a relation cannot be mutated because it's already loaded.

data/lib/active_record/gem_version.rb

@@ -7,7 +7,7 @@ module ActiveRecord
   module VERSION
     MAJOR = 4
     MINOR = 2
-    TINY  = 4
+    TINY  = 10
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/active_record/legacy_yaml_adapter.rb

@@ -0,0 +1,30 @@
+module ActiveRecord
+  module LegacyYamlAdapter
+    def self.convert(klass, coder)
+      return coder unless coder.is_a?(Psych::Coder)
+
+      case coder["active_record_yaml_version"]
+      when 0 then coder
+      else
+        if coder["attributes"].is_a?(AttributeSet)
+          coder
+        else
+          Rails41.convert(klass, coder)
+        end
+      end
+    end
+
+    module Rails41
+      def self.convert(klass, coder)
+        attributes = klass.attributes_builder
+          .build_from_database(coder["attributes"])
+        new_record = coder["attributes"][klass.primary_key].blank?
+
+        {
+          "attributes" => attributes,
+          "new_record" => new_record,
+        }
+      end
+    end
+  end
+end

data/lib/active_record/migration.rb

@@ -420,7 +420,10 @@ module ActiveRecord
         new.migrate direction
       end
 
-      # Disable DDL transactions for this migration.
+      # Disable the transaction wrapping this migration.
+      # You can still create your own transactions even after calling #disable_ddl_transaction!
+      #
+      # For more details read the {"Transactional Migrations" section above}[rdoc-ref:Migration].
       def disable_ddl_transaction!
         @disable_ddl_transaction = true
       end
@@ -877,14 +880,15 @@ module ActiveRecord
         migrations_paths.first
       end
 
+      def parse_migration_filename(filename) # :nodoc:
+        File.basename(filename).scan(/\A([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/).first
+      end
+
       def migrations(paths)
         paths = Array(paths)
 
-        files = Dir[*paths.map { |p| "#{p}/**/[0-9]*_*.rb" }]
-
-        migrations = files.map do |file|
-          version, name, scope = file.scan(/([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/).first
-
+        migrations = migration_files(paths).map do |file|
+          version, name, scope = parse_migration_filename(file)
           raise IllegalMigrationNameError.new(file) unless version
           version = version.to_i
           name = name.camelize
@@ -895,6 +899,30 @@ module ActiveRecord
         migrations.sort_by(&:version)
       end
 
+      def migrations_status(paths)
+        paths = Array(paths)
+
+        db_list = ActiveRecord::SchemaMigration.normalized_versions
+
+        file_list = migration_files(paths).map do |file|
+          version, name, scope = parse_migration_filename(file)
+          raise IllegalMigrationNameError.new(file) unless version
+          version = ActiveRecord::SchemaMigration.normalize_migration_number(version)
+          status = db_list.delete(version) ? "up" : "down"
+          [status, version, (name + scope).humanize]
+        end.compact
+
+        db_list.map! do |version|
+          ["up", version, "********** NO FILE **********"]
+        end
+
+        (db_list + file_list).sort_by { |_, version, _| version }
+      end
+
+      def migration_files(paths)
+        Dir[*paths.flat_map { |path| "#{path}/**/[0-9]*_*.rb" }]
+      end
+
       private
 
       def move(direction, migrations_paths, steps)

data/lib/active_record/model_schema.rb

@@ -247,7 +247,7 @@ module ActiveRecord
       # Returns a hash where the keys are column names and the values are
       # default values when instantiating the AR object for this table.
       def column_defaults
-        _default_attributes.to_hash
+        _default_attributes.dup.to_hash
       end
 
       def _default_attributes # :nodoc:
@@ -304,6 +304,8 @@ module ActiveRecord
         @default_attributes = nil
         @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
         @relation           = nil
+
+        initialize_find_by_cache
       end
 
       private

data/lib/active_record/nested_attributes.rb

@@ -523,7 +523,7 @@ module ActiveRecord
     # has_destroy_flag? or if a <tt>:reject_if</tt> proc exists for this
     # association and evaluates to +true+.
     def reject_new_record?(association_name, attributes)
-      has_destroy_flag?(attributes) || call_reject_if(association_name, attributes)
+      will_be_destroyed?(association_name, attributes) || call_reject_if(association_name, attributes)
     end
 
     # Determines if a record with the particular +attributes+ should be
@@ -532,7 +532,8 @@ module ActiveRecord
     #
     # Returns false if there is a +destroy_flag+ on the attributes.
     def call_reject_if(association_name, attributes)
-      return false if has_destroy_flag?(attributes)
+      return false if will_be_destroyed?(association_name, attributes)
+
       case callback = self.nested_attributes_options[association_name][:reject_if]
       when Symbol
         method(callback).arity == 0 ? send(callback) : send(callback, attributes)
@@ -541,6 +542,15 @@ module ActiveRecord
       end
     end
 
+    # Only take into account the destroy flag if <tt>:allow_destroy</tt> is true
+    def will_be_destroyed?(association_name, attributes)
+      allow_destroy?(association_name) && has_destroy_flag?(attributes)
+    end
+
+    def allow_destroy?(association_name)
+      self.nested_attributes_options[association_name][:allow_destroy]
+    end
+
     def raise_nested_attributes_record_not_found!(association_name, record_id)
       raise RecordNotFound, "Couldn't find #{self.class._reflect_on_association(association_name).klass.name} with ID=#{record_id} for #{self.class.name} with ID=#{id}"
     end

data/lib/active_record/railtie.rb

@@ -57,8 +57,10 @@ module ActiveRecord
     console do |app|
       require "active_record/railties/console_sandbox" if app.sandbox?
       require "active_record/base"
-      console = ActiveSupport::Logger.new(STDERR)
-      Rails.logger.extend ActiveSupport::Logger.broadcast console
+      unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDERR, STDOUT)
+        console = ActiveSupport::Logger.new(STDERR)
+        Rails.logger.extend ActiveSupport::Logger.broadcast console
+      end
     end
 
     runner do

data/lib/active_record/railties/databases.rake

@@ -63,6 +63,8 @@ db_namespace = namespace :db do
   namespace :migrate do
     # desc  'Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x).'
     task :redo => [:environment, :load_config] do
+      raise "Empty VERSION provided" if ENV["VERSION"] && ENV["VERSION"].empty?
+
       if ENV['VERSION']
         db_namespace['migrate:down'].invoke
         db_namespace['migrate:up'].invoke
@@ -77,16 +79,17 @@ db_namespace = namespace :db do
 
     # desc 'Runs the "up" for a given migration VERSION.'
     task :up => [:environment, :load_config] do
+      raise "VERSION is required" if ENV["VERSION"] && ENV["VERSION"].empty?
+
       version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise 'VERSION is required' unless version
       ActiveRecord::Migrator.run(:up, ActiveRecord::Migrator.migrations_paths, version)
       db_namespace['_dump'].invoke
     end
 
     # desc 'Runs the "down" for a given migration VERSION.'
     task :down => [:environment, :load_config] do
+      raise "VERSION is required - To go down one migration, use db:rollback" if ENV["VERSION"] && ENV["VERSION"].empty?
       version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
-      raise 'VERSION is required - To go down one migration, run db:rollback' unless version
       ActiveRecord::Migrator.run(:down, ActiveRecord::Migrator.migrations_paths, version)
       db_namespace['_dump'].invoke
     end
@@ -96,26 +99,13 @@ db_namespace = namespace :db do
       unless ActiveRecord::SchemaMigration.table_exists?
         abort 'Schema migrations table does not exist yet.'
       end
-      db_list = ActiveRecord::SchemaMigration.normalized_versions
-
-      file_list =
-          ActiveRecord::Migrator.migrations_paths.flat_map do |path|
-            # match "20091231235959_some_name.rb" and "001_some_name.rb" pattern
-            Dir.foreach(path).grep(/^(\d{3,})_(.+)\.rb$/) do
-              version = ActiveRecord::SchemaMigration.normalize_migration_number($1)
-              status = db_list.delete(version) ? 'up' : 'down'
-              [status, version, $2.humanize]
-            end
-          end
 
-      db_list.map! do |version|
-        ['up', version, '********** NO FILE **********']
-      end
       # output
       puts "\ndatabase: #{ActiveRecord::Base.connection_config[:database]}\n\n"
       puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
       puts "-" * 50
-      (db_list + file_list).sort_by { |_, version, _| version }.each do |status, version, name|
+      paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
+      ActiveRecord::Migrator.migrations_status(paths).each do |status, version, name|
         puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
       end
       puts

data/lib/active_record/reflection.rb

@@ -7,8 +7,8 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :_reflections
-      class_attribute :aggregate_reflections
+      class_attribute :_reflections, instance_writer: false
+      class_attribute :aggregate_reflections, instance_writer: false
       self._reflections = {}
       self.aggregate_reflections = {}
     end
@@ -32,6 +32,7 @@ module ActiveRecord
     end
 
     def self.add_reflection(ar, name, reflection)
+      ar.clear_reflections_cache
       ar._reflections = ar._reflections.merge(name.to_s => reflection)
     end
 
@@ -67,16 +68,21 @@ module ActiveRecord
       #
       # @api public
       def reflections
-        ref = {}
-        _reflections.each do |name, reflection|
-          parent_name, parent_reflection = reflection.parent_reflection
-          if parent_name
-            ref[parent_name] = parent_reflection
-          else
-            ref[name] = reflection
+        @__reflections ||= begin
+          ref = {}
+
+          _reflections.each do |name, reflection|
+            parent_name, parent_reflection = reflection.parent_reflection
+
+            if parent_name
+              ref[parent_name] = parent_reflection
+            else
+              ref[name] = reflection
+            end
           end
+
+          ref
         end
-        ref
       end
 
       # Returns an array of AssociationReflection objects for all the
@@ -116,6 +122,10 @@ module ActiveRecord
       def reflect_on_all_autosave_associations
         reflections.values.select { |reflection| reflection.options[:autosave] }
       end
+
+      def clear_reflections_cache #:nodoc:
+        @__reflections = nil
+      end
     end
 
     # Holds all the methods that are shared between MacroReflection, AssociationReflection
@@ -161,6 +171,20 @@ module ActiveRecord
 
         macro
       end
+
+      def inverse_of
+        return unless inverse_name
+
+        @inverse_of ||= klass._reflect_on_association inverse_name
+      end
+
+      def check_validity_of_inverse!
+        unless polymorphic?
+          if has_inverse? && inverse_of.nil?
+            raise InverseOfAssociationNotFoundError.new(self)
+          end
+        end
+      end
     end
     # Base class for AggregateReflection and AssociationReflection. Objects of
     # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
@@ -303,7 +327,7 @@ module ActiveRecord
       end
 
       def foreign_key
-        @foreign_key ||= options[:foreign_key] || derive_foreign_key
+        @foreign_key ||= options[:foreign_key] || derive_foreign_key.freeze
       end
 
       def association_foreign_key
@@ -331,14 +355,6 @@ module ActiveRecord
         check_validity_of_inverse!
       end
 
-      def check_validity_of_inverse!
-        unless polymorphic?
-          if has_inverse? && inverse_of.nil?
-            raise InverseOfAssociationNotFoundError.new(self)
-          end
-        end
-      end
-
       def check_preloadable!
         return unless scope
 
@@ -387,12 +403,6 @@ module ActiveRecord
         inverse_name
       end
 
-      def inverse_of
-        return unless inverse_name
-
-        @inverse_of ||= klass._reflect_on_association inverse_name
-      end
-
       def polymorphic_inverse_of(associated_class)
         if has_inverse?
           if inverse_relationship = associated_class._reflect_on_association(options[:inverse_of])
@@ -865,6 +875,8 @@ module ActiveRecord
           klass.primary_key || raise(UnknownPrimaryKey.new(klass))
         end
 
+        def inverse_name; delegate_reflection.send(:inverse_name); end
+
       private
         def derive_class_name
           # get the class_name of the belongs_to association of the through reflection