activerecord 5.0.7 → 5.1.7

data/lib/active_record/dynamic_matchers.rb

@@ -1,6 +1,7 @@
+
 module ActiveRecord
   module DynamicMatchers #:nodoc:
-    def respond_to?(name, include_private = false)
+    def respond_to_missing?(name, include_private = false)
       if self == Base
         super
       else
@@ -11,111 +12,111 @@ module ActiveRecord
 
     private
 
-    def method_missing(name, *arguments, &block)
-      match = Method.match(self, name)
+      def method_missing(name, *arguments, &block)
+        match = Method.match(self, name)
 
-      if match && match.valid?
-        match.define
-        send(name, *arguments, &block)
-      else
-        super
+        if match && match.valid?
+          match.define
+          send(name, *arguments, &block)
+        else
+          super
+        end
       end
-    end
 
-    class Method
-      @matchers = []
+      class Method
+        @matchers = []
 
-      class << self
-        attr_reader :matchers
+        class << self
+          attr_reader :matchers
 
-        def match(model, name)
-          klass = matchers.find { |k| name =~ k.pattern }
-          klass.new(model, name) if klass
-        end
+          def match(model, name)
+            klass = matchers.find { |k| k.pattern.match?(name) }
+            klass.new(model, name) if klass
+          end
 
-        def pattern
-          @pattern ||= /\A#{prefix}_([_a-zA-Z]\w*)#{suffix}\Z/
-        end
+          def pattern
+            @pattern ||= /\A#{prefix}_([_a-zA-Z]\w*)#{suffix}\Z/
+          end
 
-        def prefix
-          raise NotImplementedError
-        end
+          def prefix
+            raise NotImplementedError
+          end
 
-        def suffix
-          ''
+          def suffix
+            ""
+          end
         end
-      end
 
-      attr_reader :model, :name, :attribute_names
+        attr_reader :model, :name, :attribute_names
 
-      def initialize(model, name)
-        @model           = model
-        @name            = name.to_s
-        @attribute_names = @name.match(self.class.pattern)[1].split('_and_')
-        @attribute_names.map! { |n| @model.attribute_aliases[n] || n }
-      end
+        def initialize(model, name)
+          @model           = model
+          @name            = name.to_s
+          @attribute_names = @name.match(self.class.pattern)[1].split("_and_")
+          @attribute_names.map! { |n| @model.attribute_aliases[n] || n }
+        end
 
-      def valid?
-        attribute_names.all? { |name| model.columns_hash[name] || model.reflect_on_aggregation(name.to_sym) }
-      end
+        def valid?
+          attribute_names.all? { |name| model.columns_hash[name] || model.reflect_on_aggregation(name.to_sym) }
+        end
 
-      def define
-        model.class_eval <<-CODE, __FILE__, __LINE__ + 1
-          def self.#{name}(#{signature})
-            #{body}
-          end
-        CODE
-      end
+        def define
+          model.class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def self.#{name}(#{signature})
+              #{body}
+            end
+          CODE
+        end
 
-      private
+        private
 
-      def body
-        "#{finder}(#{attributes_hash})"
-      end
+          def body
+            "#{finder}(#{attributes_hash})"
+          end
 
-      # The parameters in the signature may have reserved Ruby words, in order
-      # to prevent errors, we start each param name with `_`.
-      def signature
-        attribute_names.map { |name| "_#{name}" }.join(', ')
-      end
+          # The parameters in the signature may have reserved Ruby words, in order
+          # to prevent errors, we start each param name with `_`.
+          def signature
+            attribute_names.map { |name| "_#{name}" }.join(", ")
+          end
 
-      # Given that the parameters starts with `_`, the finder needs to use the
-      # same parameter name.
-      def attributes_hash
-        "{" + attribute_names.map { |name| ":#{name} => _#{name}" }.join(',') + "}"
-      end
+          # Given that the parameters starts with `_`, the finder needs to use the
+          # same parameter name.
+          def attributes_hash
+            "{" + attribute_names.map { |name| ":#{name} => _#{name}" }.join(",") + "}"
+          end
 
-      def finder
-        raise NotImplementedError
+          def finder
+            raise NotImplementedError
+          end
       end
-    end
 
-    class FindBy < Method
-      Method.matchers << self
+      class FindBy < Method
+        Method.matchers << self
 
-      def self.prefix
-        "find_by"
-      end
+        def self.prefix
+          "find_by"
+        end
 
-      def finder
-        "find_by"
+        def finder
+          "find_by"
+        end
       end
-    end
 
-    class FindByBang < Method
-      Method.matchers << self
+      class FindByBang < Method
+        Method.matchers << self
 
-      def self.prefix
-        "find_by"
-      end
+        def self.prefix
+          "find_by"
+        end
 
-      def self.suffix
-        "!"
-      end
+        def self.suffix
+          "!"
+        end
 
-      def finder
-        "find_by!"
+        def finder
+          "find_by!"
+        end
       end
-    end
   end
 end

data/lib/active_record/enum.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/object/deep_dup'
+require "active_support/core_ext/object/deep_dup"
 
 module ActiveRecord
   # Declare an enum attribute where the values map to integers in the database,
@@ -140,9 +140,11 @@ module ActiveRecord
         end
       end
 
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
-      attr_reader :name, :mapping, :subtype
+        attr_reader :name, :mapping, :subtype
     end
 
     def enum(definitions)
@@ -216,18 +218,18 @@ module ActiveRecord
 
       def detect_enum_conflict!(enum_name, method_name, klass_method = false)
         if klass_method && dangerous_class_method?(method_name)
-          raise_conflict_error(enum_name, method_name, type: 'class')
+          raise_conflict_error(enum_name, method_name, type: "class")
         elsif !klass_method && dangerous_attribute_method?(method_name)
           raise_conflict_error(enum_name, method_name)
         elsif !klass_method && method_defined_within?(method_name, _enum_methods_module, Module)
-          raise_conflict_error(enum_name, method_name, source: 'another enum')
+          raise_conflict_error(enum_name, method_name, source: "another enum")
         end
       end
 
-      def raise_conflict_error(enum_name, method_name, type: 'instance', source: 'Active Record')
+      def raise_conflict_error(enum_name, method_name, type: "instance", source: "Active Record")
         raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
           enum: enum_name,
-          klass: self.name,
+          klass: name,
           type: type,
           method: method_name,
           source: source

data/lib/active_record/errors.rb

@@ -1,5 +1,4 @@
 module ActiveRecord
-
   # = Active Record Errors
   #
   # Generic Active Record exception class.
@@ -44,7 +43,7 @@ module ActiveRecord
 
   # Raised when connection to the database could not been established (for example when
   # {ActiveRecord::Base.connection=}[rdoc-ref:ConnectionHandling#connection]
-  # is given a nil object).
+  # is given a +nil+ object).
   class ConnectionNotEstablished < ActiveRecordError
   end
 
@@ -96,20 +95,9 @@ module ActiveRecord
   #
   # Wraps the underlying database error as +cause+.
   class StatementInvalid < ActiveRecordError
-
-    def initialize(message = nil, original_exception = nil)
-      if original_exception
-        ActiveSupport::Deprecation.warn("Passing #original_exception is deprecated and has no effect. " \
-                                        "Exceptions will automatically capture the original exception.", caller)
-      end
-
+    def initialize(message = nil)
       super(message || $!.try(:message))
     end
-
-    def original_exception
-      ActiveSupport::Deprecation.warn("#original_exception is deprecated. Use #cause instead.", caller)
-      cause
-    end
   end
 
   # Defunct wrapper class kept for compatibility.
@@ -125,10 +113,52 @@ module ActiveRecord
   class InvalidForeignKey < WrappedDatabaseException
   end
 
+  # Raised when a foreign key constraint cannot be added because the column type does not match the referenced column type.
+  class MismatchedForeignKey < StatementInvalid
+    def initialize(
+      adapter = nil,
+      message: nil,
+      sql: nil,
+      binds: nil,
+      table: nil,
+      foreign_key: nil,
+      target_table: nil,
+      primary_key: nil,
+      primary_key_column: nil
+    )
+      if table
+        type = primary_key_column.bigint? ? :bigint : primary_key_column.type
+        msg = <<-EOM.squish
+          Column `#{foreign_key}` on table `#{table}` does not match column `#{primary_key}` on `#{target_table}`,
+          which has type `#{primary_key_column.sql_type}`.
+          To resolve this issue, change the type of the `#{foreign_key}` column on `#{table}` to be :#{type}.
+          (For example `t.#{type} :#{foreign_key}`).
+        EOM
+      else
+        msg = <<-EOM.squish
+          There is a mismatch between the foreign key and primary key column types.
+          Verify that the foreign key column type and the primary key of the associated table match types.
+        EOM
+      end
+      if message
+        msg << "\nOriginal message: #{message}"
+      end
+      super(msg)
+    end
+  end
+
+  # Raised when a record cannot be inserted or updated because it would violate a not null constraint.
+  class NotNullViolation < StatementInvalid
+  end
+
   # Raised when a record cannot be inserted or updated because a value too long for a column type.
   class ValueTooLong < StatementInvalid
   end
 
+  # Raised when values that executed are out of range.
+  class RangeError < StatementInvalid
+  end
+
   # Raised when number of bind variables in statement given to +:condition+ key
   # (for example, when using {ActiveRecord::Base.find}[rdoc-ref:FinderMethods#find] method)
   # does not match number of expected values supplied.
@@ -166,7 +196,6 @@ module ActiveRecord
         super("Stale object error.")
       end
     end
-
   end
 
   # Raised when association is being configured improperly or user tries to use
@@ -285,6 +314,26 @@ module ActiveRecord
   class TransactionIsolationError < ActiveRecordError
   end
 
+  # TransactionRollbackError will be raised when a transaction is rolled
+  # back by the database due to a serialization failure or a deadlock.
+  #
+  # See the following:
+  #
+  # * http://www.postgresql.org/docs/current/static/transaction-iso.html
+  # * https://dev.mysql.com/doc/refman/5.7/en/error-messages-server.html#error_er_lock_deadlock
+  class TransactionRollbackError < StatementInvalid
+  end
+
+  # SerializationFailure will be raised when a transaction is rolled
+  # back by the database due to a serialization failure.
+  class SerializationFailure < TransactionRollbackError
+  end
+
+  # Deadlocked will be raised when a transaction is rolled
+  # back by the database when a deadlock is encountered.
+  class Deadlocked < TransactionRollbackError
+  end
+
   # IrreversibleOrderError is raised when a relation's order is too complex for
   # +reverse_order+ to automatically reverse.
   class IrreversibleOrderError < ActiveRecordError

data/lib/active_record/explain.rb

@@ -1,5 +1,4 @@
-require 'active_support/lazy_load_hooks'
-require 'active_record/explain_registry'
+require "active_record/explain_registry"
 
 module ActiveRecord
   module Explain

data/lib/active_record/explain_registry.rb

@@ -1,4 +1,4 @@
-require 'active_support/per_thread_registry'
+require "active_support/per_thread_registry"
 
 module ActiveRecord
   # This is a thread locals registry for EXPLAIN. For example

data/lib/active_record/explain_subscriber.rb

@@ -1,5 +1,5 @@
-require 'active_support/notifications'
-require 'active_record/explain_registry'
+require "active_support/notifications"
+require "active_record/explain_registry"
 
 module ActiveRecord
   class ExplainSubscriber # :nodoc:
@@ -18,10 +18,13 @@ module ActiveRecord
     #
     # On the other hand, we want to monitor the performance of our real database
     # queries, not the performance of the access to the query cache.
-    IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN CACHE)
+    IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN)
     EXPLAINED_SQLS = /\A\s*(with|select|update|delete|insert)\b/i
     def ignore_payload?(payload)
-      payload[:exception] || IGNORED_PAYLOADS.include?(payload[:name]) || payload[:sql] !~ EXPLAINED_SQLS
+      payload[:exception] ||
+        payload[:cached] ||
+        IGNORED_PAYLOADS.include?(payload[:name]) ||
+        payload[:sql] !~ EXPLAINED_SQLS
     end
 
     ActiveSupport::Notifications.subscribe("sql.active_record", new)

data/lib/active_record/fixture_set/file.rb

@@ -1,5 +1,5 @@
-require 'erb'
-require 'yaml'
+require "erb"
+require "yaml"
 
 module ActiveRecord
   class FixtureSet
@@ -24,21 +24,21 @@ module ActiveRecord
       end
 
       def model_class
-        config_row['model_class']
+        config_row["model_class"]
       end
 
       private
         def rows
-          @rows ||= raw_rows.reject { |fixture_name, _| fixture_name == '_fixture' }
+          @rows ||= raw_rows.reject { |fixture_name, _| fixture_name == "_fixture" }
         end
 
         def config_row
           @config_row ||= begin
-            row = raw_rows.find { |fixture_name, _| fixture_name == '_fixture' }
+            row = raw_rows.find { |fixture_name, _| fixture_name == "_fixture" }
             if row
               row.last
             else
-              {'model_class': nil}
+              { 'model_class': nil }
             end
           end
         end
@@ -66,10 +66,13 @@ module ActiveRecord
         # Validate our unmarshalled data.
         def validate(data)
           unless Hash === data || YAML::Omap === data
-            raise Fixture::FormatError, 'fixture is not a hash'
+            raise Fixture::FormatError, "fixture is not a hash: #{@file}"
           end
 
-          raise Fixture::FormatError unless data.all? { |name, row| Hash === row }
+          invalid = data.reject { |_, row| Hash === row }
+          if invalid.any?
+            raise Fixture::FormatError, "fixture key is not a hash: #{@file}, keys: #{invalid.keys.inspect}"
+          end
           data
         end
     end