activerecord 4.1.15 → 4.2.0.beta1

data/lib/active_record/serializers/xml_serializer.rb

@@ -180,13 +180,9 @@ module ActiveRecord #:nodoc:
     class Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute #:nodoc:
       def compute_type
         klass = @serializable.class
-        type = if klass.serialized_attributes.key?(name)
-                 super
-               elsif klass.columns_hash.key?(name)
-                 klass.columns_hash[name].type
-               else
-                 NilClass
-               end
+        column = klass.columns_hash[name] || Type::Value.new
+
+        type = ActiveSupport::XmlMini::TYPE_NAMES[value.class.name] || column.type
 
         { :text => :string,
           :time => :datetime }[type] || type

data/lib/active_record/statement_cache.rb

@@ -14,13 +14,87 @@ module ActiveRecord
   # The relation returned by the block is cached, and for each +execute+ call the cached relation gets duped.
   # Database is queried when +to_a+ is called on the relation.
   class StatementCache
-    def initialize
-      @relation = yield
-      raise ArgumentError.new("Statement cannot be nil") if @relation.nil?
+    class Substitute; end
+
+    class Query
+      def initialize(sql)
+        @sql = sql
+      end
+
+      def sql_for(binds, connection)
+        @sql
+      end
+    end
+
+    class PartialQuery < Query
+      def initialize values
+        @values = values
+        @indexes = values.each_with_index.find_all { |thing,i|
+          Arel::Nodes::BindParam === thing
+        }.map(&:last)
+      end
+
+      def sql_for(binds, connection)
+        val = @values.dup
+        binds = binds.dup
+        @indexes.each { |i| val[i] = connection.quote(*binds.shift.reverse) }
+        val.join
+      end
+    end
+
+    def self.query(visitor, ast)
+      Query.new visitor.accept(ast, Arel::Collectors::SQLString.new).value
+    end
+
+    def self.partial_query(visitor, ast, collector)
+      collected = visitor.accept(ast, collector).value
+      PartialQuery.new collected
+    end
+
+    class Params
+      def bind; Substitute.new; end
     end
 
-    def execute
-      @relation.dup.to_a
+    class BindMap
+      def initialize(bind_values)
+        @indexes   = []
+        @bind_values = bind_values
+
+        bind_values.each_with_index do |(_, value), i|
+          if Substitute === value
+            @indexes << i
+          end
+        end
+      end
+
+      def bind(values)
+        bvs = @bind_values.map { |pair| pair.dup }
+        @indexes.each_with_index { |offset,i| bvs[offset][1] = values[i] }
+        bvs
+      end
+    end
+
+    attr_reader :bind_map, :query_builder
+
+    def self.create(connection, block = Proc.new)
+      relation      = block.call Params.new
+      bind_map      = BindMap.new relation.bind_values
+      query_builder = connection.cacheable_query relation.arel
+      new query_builder, bind_map
+    end
+
+    def initialize(query_builder, bind_map)
+      @query_builder = query_builder
+      @bind_map      = bind_map
+    end
+
+    def execute(params, klass, connection)
+      bind_values = bind_map.bind params
+
+      sql = query_builder.sql_for bind_values, connection
+
+      klass.find_by_sql sql, bind_values
     end
+    alias :call :execute
   end
 end

data/lib/active_record/store.rb

@@ -99,7 +99,7 @@ module ActiveRecord
         self.local_stored_attributes[store_attribute] |= keys
       end
 
-      def _store_accessors_module
+      def _store_accessors_module # :nodoc:
         @_store_accessors_module ||= begin
           mod = Module.new
           include mod
@@ -129,10 +129,10 @@ module ActiveRecord
 
     private
       def store_accessor_for(store_attribute)
-        @column_types[store_attribute.to_s].accessor
+        type_for_attribute(store_attribute.to_s).accessor
       end
 
-      class HashAccessor
+      class HashAccessor # :nodoc:
         def self.read(object, attribute, key)
           prepare(object, attribute)
           object.public_send(attribute)[key]
@@ -151,7 +151,7 @@ module ActiveRecord
         end
       end
 
-      class StringKeyedHashAccessor < HashAccessor
+      class StringKeyedHashAccessor < HashAccessor # :nodoc:
         def self.read(object, attribute, key)
           super object, attribute, key.to_s
         end
@@ -161,7 +161,7 @@ module ActiveRecord
         end
       end
 
-      class IndifferentHashAccessor < ActiveRecord::Store::HashAccessor
+      class IndifferentHashAccessor < ActiveRecord::Store::HashAccessor # :nodoc:
         def self.prepare(object, store_attribute)
           attribute = object.send(store_attribute)
           unless attribute.is_a?(ActiveSupport::HashWithIndifferentAccess)

data/lib/active_record/tasks/database_tasks.rb

@@ -6,7 +6,7 @@ module ActiveRecord
     # <tt>ActiveRecord::Tasks::DatabaseTasks</tt> is a utility class, which encapsulates
     # logic behind common tasks used to manage database and migrations.
     #
-    # The tasks defined here are used in rake tasks provided by Active Record.
+    # The tasks defined here are used with Rake tasks provided by Active Record.
     #
     # In order to use DatabaseTasks, a few config values need to be set. All the needed
     # config values are set by Rails already, so it's necessary to do it only if you
@@ -14,7 +14,6 @@ module ActiveRecord
     # (in such case after configuring the database tasks, you can also use the rake tasks
     # defined in Active Record).
     #
-    #
     # The possible config values are:
     #
     #   * +env+: current environment (like Rails.env).
@@ -28,7 +27,7 @@ module ActiveRecord
     # Example usage of +DatabaseTasks+ outside Rails could look as such:
     #
     #   include ActiveRecord::Tasks
-    #   DatabaseTasks.database_configuration = YAML.load(File.read('my_database_config.yml'))
+    #   DatabaseTasks.database_configuration = YAML.load_file('my_database_config.yml')
     #   DatabaseTasks.db_dir = 'db'
     #   # other settings...
     #
@@ -59,7 +58,11 @@ module ActiveRecord
       end
 
       def fixtures_path
-        @fixtures_path ||= File.join(root, 'test', 'fixtures')
+        @fixtures_path ||= if ENV['FIXTURES_PATH']
+                             File.join(root, ENV['FIXTURES_PATH'])
+                           else
+                             File.join(root, 'test', 'fixtures')
+                           end
       end
 
       def root
@@ -107,6 +110,8 @@ module ActiveRecord
       def drop(*arguments)
         configuration = arguments.first
         class_for_adapter(configuration['adapter']).new(*arguments).drop
+      rescue ActiveRecord::NoDatabaseError
+        $stderr.puts "Database '#{configuration['database']}' does not exist"
       rescue Exception => error
         $stderr.puts error, *(error.backtrace)
         $stderr.puts "Couldn't drop #{configuration['database']}"
@@ -122,6 +127,16 @@ module ActiveRecord
         }
       end
 
+      def migrate
+        verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+        scope   = ENV['SCOPE']
+        Migration.verbose = verbose
+        Migrator.migrate(Migrator.migrations_paths, version) do |migration|
+          scope.blank? || scope == migration.scope
+        end
+      end
+
       def charset_current(environment = env)
         charset ActiveRecord::Base.configurations[environment]
       end
@@ -144,6 +159,18 @@ module ActiveRecord
         class_for_adapter(configuration['adapter']).new(configuration).purge
       end
 
+      def purge_all
+        each_local_configuration { |configuration|
+          purge configuration
+        }
+      end
+
+      def purge_current(environment = env)
+        each_current_configuration(environment) { |configuration|
+          purge configuration
+        }
+      end
+
       def structure_dump(*arguments)
         configuration = arguments.first
         filename = arguments.delete_at 1
@@ -157,6 +184,10 @@ module ActiveRecord
       end
 
       def load_schema(format = ActiveRecord::Base.schema_format, file = nil)
+        ActiveSupport::Deprecation.warn(<<-MESSAGE.strip_heredoc)
+          This method will act on a specific connection in the future.
+          To act on the current connection, use `load_schema_current` instead.
+        MESSAGE
         load_schema_current(format, file)
       end
 
@@ -167,11 +198,13 @@ module ActiveRecord
         when :ruby
           file ||= File.join(db_dir, "schema.rb")
           check_schema_file(file)
+          purge(configuration)
           ActiveRecord::Base.establish_connection(configuration)
           load(file)
         when :sql
           file ||= File.join(db_dir, "structure.sql")
           check_schema_file(file)
+          purge(configuration)
           structure_load(configuration, file)
         else
           raise ArgumentError, "unknown format #{format.inspect}"
@@ -182,7 +215,6 @@ module ActiveRecord
         each_current_configuration(environment) { |configuration|
           load_schema_for configuration, format, file
         }
-        ActiveRecord::Base.establish_connection(environment.to_sym)
       end
 
       def check_schema_file(filename)

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -124,7 +124,7 @@ IDENTIFIED BY '#{configuration['password']}' WITH GRANT OPTION;
       end
 
       def root_password
-        $stdout.print "Please provide the root password for your mysql installation\n>"
+        $stdout.print "Please provide the root password for your MySQL installation\n>"
         $stdin.gets.strip
       end
 

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -51,10 +51,10 @@ module ActiveRecord
           search_path = search_path.split(",").map{|search_path_part| "--schema=#{Shellwords.escape(search_path_part.strip)}" }.join(" ")
         end
 
-        command = "pg_dump -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(configuration['database'])}"
+        command = "pg_dump -i -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(configuration['database'])}"
         raise 'Error dumping database' unless Kernel.system(command)
 
-        File.open(filename, "a") { |f| f << "SET search_path TO #{ActiveRecord::Base.connection.schema_search_path};\n\n" }
+        File.open(filename, "a") { |f| f << "SET search_path TO #{connection.schema_search_path};\n\n" }
       end
 
       def structure_load(filename)

data/lib/active_record/timestamp.rb

@@ -1,4 +1,3 @@
-
 module ActiveRecord
   # = Active Record Timestamp
   #
@@ -48,8 +47,9 @@ module ActiveRecord
         current_time = current_time_from_proper_timezone
 
         all_timestamp_attributes.each do |column|
-          if respond_to?(column) && respond_to?("#{column}=") && self.send(column).nil?
-            write_attribute(column.to_s, current_time)
+          column = column.to_s
+          if has_attribute?(column) && !attribute_present?(column)
+            write_attribute(column, current_time)
           end
         end
       end
@@ -99,9 +99,11 @@ module ActiveRecord
     end
 
     def max_updated_column_timestamp(timestamp_names = timestamp_attributes_for_update)
-      if (timestamps = timestamp_names.map { |attr| self[attr] }.compact).present?
-        timestamps.map { |ts| ts.to_time }.max
-      end
+      timestamp_names
+        .map { |attr| self[attr] }
+        .compact
+        .map(&:to_time)
+        .max
     end
 
     def current_time_from_proper_timezone
@@ -112,7 +114,7 @@ module ActiveRecord
     def clear_timestamp_attributes
       all_timestamp_attributes_in_model.each do |attribute_name|
         self[attribute_name] = nil
-        changed_attributes.delete(attribute_name)
+        clear_attribute_changes([attribute_name])
       end
     end
   end

data/lib/active_record/transactions.rb

@@ -1,15 +1,25 @@
-require 'thread'
-
 module ActiveRecord
   # See ActiveRecord::Transactions::ClassMethods for documentation.
   module Transactions
     extend ActiveSupport::Concern
     ACTIONS = [:create, :destroy, :update]
+    CALLBACK_WARN_MESSAGE = <<-EOF
+Currently, Active Record will rescue any errors raised within
+after_rollback/after_commit callbacks and print them to the logs. In the next
+version, these errors will no longer be rescued. Instead, they will simply
+bubble just like other Active Record callbacks.
+
+You can opt into the new behavior and remove this warning by setting
+config.active_record.raise_in_transactional_callbacks to true.
+EOF
 
     included do
       define_callbacks :commit, :rollback,
                        terminator: ->(_, result) { result == false },
                        scope: [:kind, :name]
+
+      mattr_accessor :raise_in_transactional_callbacks, instance_writer: false
+      self.raise_in_transactional_callbacks = false
     end
 
     # = Active Record Transactions
@@ -225,6 +235,9 @@ module ActiveRecord
       def after_commit(*args, &block)
         set_options_for_callbacks!(args)
         set_callback(:commit, :after, *args, &block)
+        unless ActiveRecord::Base.raise_in_transactional_callbacks
+          ActiveSupport::Deprecation.warn(CALLBACK_WARN_MESSAGE)
+        end
       end
 
       # This callback is called after a create, update, or destroy are rolled back.
@@ -233,6 +246,9 @@ module ActiveRecord
       def after_rollback(*args, &block)
         set_options_for_callbacks!(args)
         set_callback(:rollback, :after, *args, &block)
+        unless ActiveRecord::Base.raise_in_transactional_callbacks
+          ActiveSupport::Deprecation.warn(CALLBACK_WARN_MESSAGE)
+        end
       end
 
       private
@@ -249,7 +265,7 @@ module ActiveRecord
 
       def assert_valid_transaction_action(actions)
         if (actions - ACTIONS).any?
-          raise ArgumentError, ":on conditions for after_commit and after_rollback callbacks have to be one of #{ACTIONS}"
+          raise ArgumentError, ":on conditions for after_commit and after_rollback callbacks have to be one of #{ACTIONS.join(",")}"
         end
       end
     end
@@ -292,16 +308,16 @@ 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! #:nodoc:
-      run_callbacks :commit if destroyed? || persisted?
+    def committed!(should_run_callbacks = true) #:nodoc:
+      run_callbacks :commit if should_run_callbacks && destroyed? || persisted?
     ensure
-      @_start_transaction_state.clear
+      force_clear_transaction_record_state
     end
 
     # 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) #:nodoc:
-      run_callbacks :rollback
+    def rolledback!(force_restore_state = false, should_run_callbacks = true) #:nodoc:
+      run_callbacks :rollback if should_run_callbacks
     ensure
       restore_transaction_record_state(force_restore_state)
       clear_transaction_record_state
@@ -328,7 +344,7 @@ module ActiveRecord
         begin
           status = yield
         rescue ActiveRecord::Rollback
-          @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
+          clear_transaction_record_state
           status = nil
         end
 
@@ -341,7 +357,7 @@ 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[:id] = id if has_attribute?(self.class.primary_key)
+      @_start_transaction_state[:id] = id
       unless @_start_transaction_state.include?(:new_record)
         @_start_transaction_state[:new_record] = @new_record
       end
@@ -349,13 +365,18 @@ module ActiveRecord
         @_start_transaction_state[:destroyed] = @destroyed
       end
       @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) + 1
-      @_start_transaction_state[:frozen?] = @attributes.frozen?
+      @_start_transaction_state[:frozen?] = frozen?
     end
 
     # Clear the new record state and id of a record.
     def clear_transaction_record_state #:nodoc:
       @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
-      @_start_transaction_state.clear if @_start_transaction_state[:level] < 1
+      force_clear_transaction_record_state if @_start_transaction_state[:level] < 1
+    end
+
+    # Force to clear the transaction record state.
+    def force_clear_transaction_record_state #:nodoc:
+      @_start_transaction_state.clear
     end
 
     # Restore the new record state and id of a record that was previously saved by a call to save_record_state.
@@ -364,17 +385,10 @@ module ActiveRecord
         transaction_level = (@_start_transaction_state[:level] || 0) - 1
         if transaction_level < 1 || force
           restore_state = @_start_transaction_state
-          was_frozen = restore_state[:frozen?]
-          @attributes = @attributes.dup if @attributes.frozen?
+          thaw unless restore_state[:frozen?]
           @new_record = restore_state[:new_record]
           @destroyed  = restore_state[:destroyed]
-          if restore_state.has_key?(:id)
-            write_attribute(self.class.primary_key, restore_state[:id])
-          else
-            @attributes.delete(self.class.primary_key)
-            @attributes_cache.delete(self.class.primary_key)
-          end
-          @attributes.freeze if was_frozen
+          write_attribute(self.class.primary_key, restore_state[:id])
         end
       end
     end

data/lib/active_record/type/binary.rb

@@ -0,0 +1,40 @@
+module ActiveRecord
+  module Type
+    class Binary < Value # :nodoc:
+      def type
+        :binary
+      end
+
+      def binary?
+        true
+      end
+
+      def type_cast(value)
+        if value.is_a?(Data)
+          value.to_s
+        else
+          super
+        end
+      end
+
+      def type_cast_for_database(value)
+        return if value.nil?
+        Data.new(super)
+      end
+
+      class Data # :nodoc:
+        def initialize(value)
+          @value = value.to_s
+        end
+
+        def to_s
+          @value
+        end
+
+        def hex
+          @value.unpack('H*')[0]
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/boolean.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module Type
+    class Boolean < Value # :nodoc:
+      def type
+        :boolean
+      end
+
+      private
+
+      def cast_value(value)
+        if value == ''
+          nil
+        else
+          ConnectionAdapters::Column::TRUE_VALUES.include?(value)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/date.rb

@@ -0,0 +1,46 @@
+module ActiveRecord
+  module Type
+    class Date < Value # :nodoc:
+      def type
+        :date
+      end
+
+      def klass
+        ::Date
+      end
+
+      def type_cast_for_schema(value)
+        "'#{value.to_s(:db)}'"
+      end
+
+      private
+
+      def cast_value(value)
+        if value.is_a?(::String)
+          return if value.empty?
+          fast_string_to_date(value) || fallback_string_to_date(value)
+        elsif value.respond_to?(:to_date)
+          value.to_date
+        else
+          value
+        end
+      end
+
+      def fast_string_to_date(string)
+        if string =~ ConnectionAdapters::Column::Format::ISO_DATE
+          new_date $1.to_i, $2.to_i, $3.to_i
+        end
+      end
+
+      def fallback_string_to_date(string)
+        new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+      end
+
+      def new_date(year, mon, mday)
+        if year && year != 0
+          ::Date.new(year, mon, mday) rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/date_time.rb

@@ -0,0 +1,43 @@
+module ActiveRecord
+  module Type
+    class DateTime < Value # :nodoc:
+      include TimeValue
+
+      def type
+        :datetime
+      end
+
+      def type_cast_for_database(value)
+        zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+
+        if value.acts_like?(:time)
+          value.send(zone_conversion_method)
+        else
+          super
+        end
+      end
+
+      private
+
+      def cast_value(string)
+        return string unless string.is_a?(::String)
+        return if string.empty?
+
+        fast_string_to_time(string) || fallback_string_to_time(string)
+      end
+
+      # '0.123456' -> 123456
+      # '1.123456' -> 123456
+      def microseconds(time)
+        time[:sec_fraction] ? (time[:sec_fraction] * 1_000_000).to_i : 0
+      end
+
+      def fallback_string_to_time(string)
+        time_hash = ::Date._parse(string)
+        time_hash[:sec_fraction] = microseconds(time_hash)
+
+        new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
+      end
+    end
+  end
+end

data/lib/active_record/type/decimal.rb

@@ -0,0 +1,40 @@
+module ActiveRecord
+  module Type
+    class Decimal < Value # :nodoc:
+      include Numeric
+
+      def type
+        :decimal
+      end
+
+      def type_cast_for_schema(value)
+        value.to_s
+      end
+
+      private
+
+      def cast_value(value)
+        case value
+        when ::Float
+          BigDecimal(value, float_precision)
+        when ::Numeric, ::String
+          BigDecimal(value, precision.to_i)
+        else
+          if value.respond_to?(:to_d)
+            value.to_d
+          else
+            cast_value(value.to_s)
+          end
+        end
+      end
+
+      def float_precision
+        if precision.to_i > ::Float::DIG + 1
+          ::Float::DIG + 1
+        else
+          precision.to_i
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/decimal_without_scale.rb

@@ -0,0 +1,11 @@
+require 'active_record/type/integer'
+
+module ActiveRecord
+  module Type
+    class DecimalWithoutScale < Integer # :nodoc:
+      def type
+        :decimal
+      end
+    end
+  end
+end

data/lib/active_record/type/float.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module Type
+    class Float < Value # :nodoc:
+      include Numeric
+
+      def type
+        :float
+      end
+
+      alias type_cast_for_database type_cast
+
+      private
+
+      def cast_value(value)
+        value.to_f
+      end
+    end
+  end
+end