activerecord 4.1.16 → 4.2.11.3

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -31,6 +31,7 @@ module ActiveRecord
           end
           establish_connection configuration
         else
+          $stderr.puts error.inspect
           $stderr.puts "Couldn't create database for #{configuration.inspect}, #{creation_options.inspect}"
           $stderr.puts "(If you set the charset manually, make sure you have a matching collation)" if configuration['encoding']
         end
@@ -55,21 +56,20 @@ module ActiveRecord
       end
 
       def structure_dump(filename)
-        args = prepare_command_options('mysqldump')
+        args = prepare_command_options
         args.concat(["--result-file", "#{filename}"])
         args.concat(["--no-data"])
         args.concat(["#{configuration['database']}"])
-        unless Kernel.system(*args)
-          $stderr.puts "Could not dump the database structure. "\
-                       "Make sure `mysqldump` is in your PATH and check the command output for warnings."
-        end
+
+        run_cmd('mysqldump', args, 'dumping')
       end
 
       def structure_load(filename)
-        args = prepare_command_options('mysql')
+        args = prepare_command_options
         args.concat(['--execute', %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}])
         args.concat(["--database", "#{configuration['database']}"])
-        Kernel.system(*args)
+
+        run_cmd('mysql', args, 'loading')
       end
 
       private
@@ -124,12 +124,12 @@ 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
 
-      def prepare_command_options(command)
-        args = {
+      def prepare_command_options
+        {
           'host'      => '--host',
           'port'      => '--port',
           'socket'    => '--socket',
@@ -142,8 +142,17 @@ IDENTIFIED BY '#{configuration['password']}' WITH GRANT OPTION;
           'sslcipher' => '--ssl-cipher',
           'sslkey'    => '--ssl-key'
         }.map { |opt, arg| "#{arg}=#{configuration[opt]}" if configuration[opt] }.compact
+      end
+
+      def run_cmd(cmd, args, action)
+        fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
+      end
 
-        [command, *args]
+      def run_cmd_error(cmd, args, action)
+        msg = "failed to execute:\n"
+        msg << "#{cmd}"
+        msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
+        msg
       end
     end
   end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -1,5 +1,3 @@
-require 'shellwords'
-
 module ActiveRecord
   module Tasks # :nodoc:
     class PostgreSQLDatabaseTasks # :nodoc:
@@ -46,20 +44,22 @@ module ActiveRecord
 
       def structure_dump(filename)
         set_psql_env
+        args = ['-s', '-x', '-O', '-f', filename]
         search_path = configuration['schema_search_path']
         unless search_path.blank?
-          search_path = search_path.split(",").map{|search_path_part| "--schema=#{Shellwords.escape(search_path_part.strip)}" }.join(" ")
+          args += search_path.split(',').map do |part|
+            "--schema=#{part.strip}"
+          end
         end
-
-        command = "pg_dump -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" }
+        args << configuration['database']
+        run_cmd('pg_dump', args, 'dumping')
+        File.open(filename, "a") { |f| f << "SET search_path TO #{connection.schema_search_path};\n\n" }
       end
 
       def structure_load(filename)
         set_psql_env
-        Kernel.system("psql -q -f #{Shellwords.escape(filename)} #{configuration['database']}")
+        args = [ '-q', '-f', filename, configuration['database'] ]
+        run_cmd('psql', args, 'loading')
       end
 
       private
@@ -85,6 +85,17 @@ module ActiveRecord
         ENV['PGPASSWORD'] = configuration['password'].to_s if configuration['password']
         ENV['PGUSER']     = configuration['username'].to_s if configuration['username']
       end
+
+      def run_cmd(cmd, args, action)
+        fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
+      end
+
+      def run_cmd_error(cmd, args, action)
+        msg = "failed to execute:\n"
+        msg << "#{cmd} #{args.join(' ')}\n\n"
+        msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
+        msg
+      end
     end
   end
 end

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,27 @@
-require 'thread'
-
 module ActiveRecord
   # See ActiveRecord::Transactions::ClassMethods for documentation.
   module Transactions
     extend ActiveSupport::Concern
+    #:nodoc:
     ACTIONS = [:create, :destroy, :update]
+    #:nodoc:
+    CALLBACK_WARN_MESSAGE = "Currently, Active Record suppresses errors raised " \
+      "within `after_rollback`/`after_commit` callbacks and only print them to " \
+      "the logs. In the next version, these errors will no longer be suppressed. " \
+      "Instead, the errors will propagate normally just like in other Active " \
+      "Record callbacks.\n" \
+      "\n" \
+      "You can opt into the new behavior and remove this warning by setting:\n" \
+      "\n" \
+      "  config.active_record.raise_in_transactional_callbacks = true\n\n"
 
     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 +237,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 +248,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
@@ -292,16 +310,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_commit_callbacks 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_rollback_callbacks if should_run_callbacks
     ensure
       restore_transaction_record_state(force_restore_state)
       clear_transaction_record_state
@@ -310,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
@@ -328,34 +350,41 @@ 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
 
         raise ActiveRecord::Rollback unless status
       end
       status
+    ensure
+      if @transaction_state && @transaction_state.committed?
+        clear_transaction_record_state
+      end
     end
 
     protected
 
     # 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)
-      unless @_start_transaction_state.include?(:new_record)
-        @_start_transaction_state[:new_record] = @new_record
-      end
-      unless @_start_transaction_state.include?(:destroyed)
-        @_start_transaction_state[:destroyed] = @destroyed
-      end
+      @_start_transaction_state[:id] = id
+      @_start_transaction_state.reverse_merge!(
+        new_record: @new_record,
+        destroyed: @destroyed,
+        frozen?: frozen?,
+      )
       @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) + 1
-      @_start_transaction_state[:frozen?] = @attributes.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 +393,14 @@ 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
           @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)
+          pk = self.class.primary_key
+          if pk && read_attribute(pk) != restore_state[:id]
+            write_attribute(pk, restore_state[:id])
           end
-          @attributes.freeze if was_frozen
+          freeze if restore_state[:frozen?]
         end
       end
     end

data/lib/active_record/type/big_integer.rb

@@ -0,0 +1,13 @@
+require 'active_record/type/integer'
+
+module ActiveRecord
+  module Type
+    class BigInteger < Integer # :nodoc:
+      private
+
+      def max_value
+        ::Float::INFINITY
+      end
+    end
+  end
+end

data/lib/active_record/type/binary.rb

@@ -0,0 +1,50 @@
+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
+
+      def changed_in_place?(raw_old_value, value)
+        old_value = type_cast_from_database(raw_old_value)
+        old_value != value
+      end
+
+      class Data # :nodoc:
+        def initialize(value)
+          @value = value.to_s
+        end
+
+        def to_s
+          @value
+        end
+        alias_method :to_str, :to_s
+
+        def hex
+          @value.unpack('H*')[0]
+        end
+
+        def ==(other)
+          other == to_s || super
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/boolean.rb

@@ -0,0 +1,31 @@
+module ActiveRecord
+  module Type
+    class Boolean < Value # :nodoc:
+      def type
+        :boolean
+      end
+
+      private
+
+      def cast_value(value)
+        if value == ''
+          nil
+        elsif ConnectionAdapters::Column::TRUE_VALUES.include?(value)
+          true
+        else
+          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
+              explicitly handle the values you would like cast to `false`.
+            MSG
+          end
+          false
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/date.rb

@@ -0,0 +1,50 @@
+module ActiveRecord
+  module Type
+    class Date < Value # :nodoc:
+      def type
+        :date
+      end
+
+      def klass
+        ::Date
+      end
+
+      def type_cast_for_database(value)
+        type_cast(value)
+      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,54 @@
+module ActiveRecord
+  module Type
+    class DateTime < Value # :nodoc:
+      include TimeValue
+
+      def type
+        :datetime
+      end
+
+      def type_cast_for_database(value)
+        return super unless value.acts_like?(:time)
+
+        zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+
+        if value.respond_to?(zone_conversion_method)
+          value = value.send(zone_conversion_method)
+        end
+
+        return value unless has_precision?
+
+        result = value.to_s(:db)
+        if value.respond_to?(:usec) && (1..6).cover?(precision)
+          "#{result}.#{sprintf("%0#{precision}d", value.usec / 10 ** (6 - precision))}"
+        else
+          result
+        end
+      end
+
+      private
+
+      alias has_precision? precision
+
+      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,64 @@
+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)
+        casted_value = case value
+        when ::Float
+          convert_float_to_big_decimal(value)
+        when ::Numeric
+          BigDecimal(value, precision.to_i)
+        when ::String
+          begin
+            value.to_d
+          rescue ArgumentError
+            BigDecimal(0)
+          end
+        else
+          if value.respond_to?(:to_d)
+            value.to_d
+          else
+            cast_value(value.to_s)
+          end
+        end
+
+        apply_scale(casted_value)
+      end
+
+      def convert_float_to_big_decimal(value)
+        if precision
+          BigDecimal(apply_scale(value), float_precision)
+        else
+          value.to_d
+        end
+      end
+
+      def float_precision
+        if precision.to_i > ::Float::DIG + 1
+          ::Float::DIG + 1
+        else
+          precision.to_i
+        end
+      end
+
+      def apply_scale(value)
+        if scale
+          value.round(scale)
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/decimal_without_scale.rb

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

data/lib/active_record/type/decorator.rb

@@ -0,0 +1,14 @@
+module ActiveRecord
+  module Type
+    module Decorator # :nodoc:
+      def init_with(coder)
+        @subtype = coder['subtype']
+        __setobj__(@subtype)
+      end
+
+      def encode_with(coder)
+        coder['subtype'] = __getobj__
+      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

data/lib/active_record/type/hash_lookup_type_map.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module Type
+    class HashLookupTypeMap < TypeMap # :nodoc:
+      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)
+        @mapping.fetch(type, block).call(type, *args)
+      end
+    end
+  end
+end