activerecord 5.2.8 → 6.0.0.beta1

data/lib/active_record/test_fixtures.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module TestFixtures
+    extend ActiveSupport::Concern
+
+    def before_setup # :nodoc:
+      setup_fixtures
+      super
+    end
+
+    def after_teardown # :nodoc:
+      super
+      teardown_fixtures
+    end
+
+    included do
+      class_attribute :fixture_path, instance_writer: false
+      class_attribute :fixture_table_names, default: []
+      class_attribute :fixture_class_names, default: {}
+      class_attribute :use_transactional_tests, default: true
+      class_attribute :use_instantiated_fixtures, default: false # true, false, or :no_instances
+      class_attribute :pre_loaded_fixtures, default: false
+      class_attribute :config, default: ActiveRecord::Base
+      class_attribute :lock_threads, default: true
+    end
+
+    module ClassMethods
+      # Sets the model class for a fixture when the class name cannot be inferred from the fixture name.
+      #
+      # Examples:
+      #
+      #   set_fixture_class some_fixture:        SomeModel,
+      #                     'namespaced/fixture' => Another::Model
+      #
+      # The keys must be the fixture names, that coincide with the short paths to the fixture files.
+      def set_fixture_class(class_names = {})
+        self.fixture_class_names = fixture_class_names.merge(class_names.stringify_keys)
+      end
+
+      def fixtures(*fixture_set_names)
+        if fixture_set_names.first == :all
+          raise StandardError, "No fixture path found. Please set `#{self}.fixture_path`." if fixture_path.blank?
+          fixture_set_names = Dir["#{fixture_path}/{**,*}/*.{yml}"].uniq
+          fixture_set_names.map! { |f| f[(fixture_path.to_s.size + 1)..-5] }
+        else
+          fixture_set_names = fixture_set_names.flatten.map(&:to_s)
+        end
+
+        self.fixture_table_names |= fixture_set_names
+        setup_fixture_accessors(fixture_set_names)
+      end
+
+      def setup_fixture_accessors(fixture_set_names = nil)
+        fixture_set_names = Array(fixture_set_names || fixture_table_names)
+        methods = Module.new do
+          fixture_set_names.each do |fs_name|
+            fs_name = fs_name.to_s
+            accessor_name = fs_name.tr("/", "_").to_sym
+
+            define_method(accessor_name) do |*fixture_names|
+              force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload
+              return_single_record = fixture_names.size == 1
+              fixture_names = @loaded_fixtures[fs_name].fixtures.keys if fixture_names.empty?
+
+              @fixture_cache[fs_name] ||= {}
+
+              instances = fixture_names.map do |f_name|
+                f_name = f_name.to_s if f_name.is_a?(Symbol)
+                @fixture_cache[fs_name].delete(f_name) if force_reload
+
+                if @loaded_fixtures[fs_name][f_name]
+                  @fixture_cache[fs_name][f_name] ||= @loaded_fixtures[fs_name][f_name].find
+                else
+                  raise StandardError, "No fixture named '#{f_name}' found for fixture set '#{fs_name}'"
+                end
+              end
+
+              return_single_record ? instances.first : instances
+            end
+            private accessor_name
+          end
+        end
+        include methods
+      end
+
+      def uses_transaction(*methods)
+        @uses_transaction = [] unless defined?(@uses_transaction)
+        @uses_transaction.concat methods.map(&:to_s)
+      end
+
+      def uses_transaction?(method)
+        @uses_transaction = [] unless defined?(@uses_transaction)
+        @uses_transaction.include?(method.to_s)
+      end
+    end
+
+    def run_in_transaction?
+      use_transactional_tests &&
+        !self.class.uses_transaction?(method_name)
+    end
+
+    def setup_fixtures(config = ActiveRecord::Base)
+      if pre_loaded_fixtures && !use_transactional_tests
+        raise RuntimeError, "pre_loaded_fixtures requires use_transactional_tests"
+      end
+
+      @fixture_cache = {}
+      @fixture_connections = []
+      @@already_loaded_fixtures ||= {}
+      @connection_subscriber = nil
+
+      # Load fixtures once and begin transaction.
+      if run_in_transaction?
+        if @@already_loaded_fixtures[self.class]
+          @loaded_fixtures = @@already_loaded_fixtures[self.class]
+        else
+          @loaded_fixtures = load_fixtures(config)
+          @@already_loaded_fixtures[self.class] = @loaded_fixtures
+        end
+
+        # Begin transactions for connections already established
+        @fixture_connections = enlist_fixture_connections
+        @fixture_connections.each do |connection|
+          connection.begin_transaction joinable: false
+          connection.pool.lock_thread = true if lock_threads
+        end
+
+        # When connections are established in the future, begin a transaction too
+        @connection_subscriber = ActiveSupport::Notifications.subscribe("!connection.active_record") do |_, _, _, _, payload|
+          spec_name = payload[:spec_name] if payload.key?(:spec_name)
+
+          if spec_name
+            begin
+              connection = ActiveRecord::Base.connection_handler.retrieve_connection(spec_name)
+            rescue ConnectionNotEstablished
+              connection = nil
+            end
+
+            if connection && !@fixture_connections.include?(connection)
+              connection.begin_transaction joinable: false
+              connection.pool.lock_thread = true if lock_threads
+              @fixture_connections << connection
+            end
+          end
+        end
+
+      # Load fixtures for every test.
+      else
+        ActiveRecord::FixtureSet.reset_cache
+        @@already_loaded_fixtures[self.class] = nil
+        @loaded_fixtures = load_fixtures(config)
+      end
+
+      # Instantiate fixtures for every test if requested.
+      instantiate_fixtures if use_instantiated_fixtures
+    end
+
+    def teardown_fixtures
+      # Rollback changes if a transaction is active.
+      if run_in_transaction?
+        ActiveSupport::Notifications.unsubscribe(@connection_subscriber) if @connection_subscriber
+        @fixture_connections.each do |connection|
+          connection.rollback_transaction if connection.transaction_open?
+          connection.pool.lock_thread = false
+        end
+        @fixture_connections.clear
+      else
+        ActiveRecord::FixtureSet.reset_cache
+      end
+
+      ActiveRecord::Base.clear_active_connections!
+    end
+
+    def enlist_fixture_connections
+      setup_shared_connection_pool
+
+      ActiveRecord::Base.connection_handler.connection_pool_list.map(&:connection)
+    end
+
+    private
+
+      # Shares the writing connection pool with connections on
+      # other handlers.
+      #
+      # In an application with a primary and replica the test fixtures
+      # need to share a connection pool so that the reading connection
+      # can see data in the open transaction on the writing connection.
+      def setup_shared_connection_pool
+        writing_handler = ActiveRecord::Base.connection_handler
+
+        ActiveRecord::Base.connection_handlers.values.each do |handler|
+          if handler != writing_handler
+            handler.connection_pool_list.each do |pool|
+              name = pool.spec.name
+              writing_connection = writing_handler.retrieve_connection_pool(name)
+              handler.send(:owner_to_pool)[name] = writing_connection
+            end
+          end
+        end
+      end
+
+      def load_fixtures(config)
+        fixtures = ActiveRecord::FixtureSet.create_fixtures(fixture_path, fixture_table_names, fixture_class_names, config)
+        Hash[fixtures.map { |f| [f.name, f] }]
+      end
+
+      def instantiate_fixtures
+        if pre_loaded_fixtures
+          raise RuntimeError, "Load fixtures before instantiating them." if ActiveRecord::FixtureSet.all_loaded_fixtures.empty?
+          ActiveRecord::FixtureSet.instantiate_all_loaded_fixtures(self, load_instances?)
+        else
+          raise RuntimeError, "Load fixtures before instantiating them." if @loaded_fixtures.nil?
+          @loaded_fixtures.each_value do |fixture_set|
+            ActiveRecord::FixtureSet.instantiate_fixtures(self, fixture_set, load_instances?)
+          end
+        end
+      end
+
+      def load_instances?
+        use_instantiated_fixtures != :no_instances
+      end
+  end
+end

data/lib/active_record/timestamp.rb

@@ -56,8 +56,7 @@ module ActiveRecord
       def touch_attributes_with_time(*names, time: nil)
         attribute_names = timestamp_attributes_for_update_in_model
         attribute_names |= names.map(&:to_s)
-        time ||= current_time_from_proper_timezone
-        attribute_names.each_with_object({}) { |attr_name, result| result[attr_name] = time }
+        attribute_names.index_with(time || current_time_from_proper_timezone)
       end
 
       private
@@ -134,11 +133,10 @@ module ActiveRecord
       self.class.send(:current_time_from_proper_timezone)
     end
 
-    def max_updated_column_timestamp(timestamp_names = timestamp_attributes_for_update_in_model)
-      timestamp_names
-        .map { |attr| self[attr] }
+    def max_updated_column_timestamp
+      timestamp_attributes_for_update_in_model
+        .map { |attr| self[attr]&.to_time }
         .compact
-        .map(&:to_time)
         .max
     end
 

data/lib/active_record/transactions.rb

@@ -306,9 +306,7 @@ module ActiveRecord
     end
 
     def save(*) #:nodoc:
-      rollback_active_record_state! do
-        with_transaction_returning_status { super }
-      end
+      with_transaction_returning_status { super }
     end
 
     def save!(*) #:nodoc:
@@ -319,17 +317,6 @@ module ActiveRecord
       with_transaction_returning_status { super }
     end
 
-    # Reset id and @new_record if the transaction rolls back.
-    def rollback_active_record_state!
-      remember_transaction_record_state
-      yield
-    rescue Exception
-      restore_transaction_record_state
-      raise
-    ensure
-      clear_transaction_record_state
-    end
-
     def before_committed! # :nodoc:
       _run_before_commit_without_transaction_enrollment_callbacks
       _run_before_commit_callbacks
@@ -340,7 +327,6 @@ 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!(should_run_callbacks: true) #:nodoc:
-      force_clear_transaction_record_state
       if should_run_callbacks && (destroyed? || persisted?)
         @_committed_already_called = true
         _run_commit_without_transaction_enrollment_callbacks
@@ -348,6 +334,7 @@ module ActiveRecord
       end
     ensure
       @_committed_already_called = false
+      force_clear_transaction_record_state
     end
 
     # Call the #after_rollback callbacks. The +force_restore_state+ argument indicates if the record
@@ -388,16 +375,10 @@ module ActiveRecord
         raise ActiveRecord::Rollback unless status
       end
       status
-    ensure
-      if @transaction_state && @transaction_state.committed?
-        clear_transaction_record_state
-      end
     end
 
-    protected
-      attr_reader :_committed_already_called, :_trigger_update_callback, :_trigger_destroy_callback
-
     private
+      attr_reader :_committed_already_called, :_trigger_update_callback, :_trigger_destroy_callback
 
       # 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

data/lib/active_record/translation.rb

@@ -10,7 +10,7 @@ module ActiveRecord
       classes = [klass]
       return classes if klass == ActiveRecord::Base
 
-      while klass != klass.base_class
+      while !klass.base_class?
         classes << klass = klass.superclass
       end
       classes

data/lib/active_record/type/adapter_specific_registry.rb

@@ -52,8 +52,6 @@ module ActiveRecord
         priority <=> other.priority
       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, :block, :adapter, :override
@@ -114,13 +112,8 @@ module ActiveRecord
         super | 4
       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 :options, :klass
-
       private
+        attr_reader :options, :klass
 
         def matches_options?(**kwargs)
           options.all? do |key, value|

data/lib/active_record/type.rb

@@ -48,12 +48,11 @@ module ActiveRecord
 
       private
 
-      def current_adapter_name
-        ActiveRecord::Base.connection.adapter_name.downcase.to_sym
-      end
+        def current_adapter_name
+          ActiveRecord::Base.connection.adapter_name.downcase.to_sym
+        end
     end
 
-    Helpers = ActiveModel::Type::Helpers
     BigInteger = ActiveModel::Type::BigInteger
     Binary = ActiveModel::Type::Binary
     Boolean = ActiveModel::Type::Boolean

data/lib/active_record/type_caster/connection.rb

@@ -14,15 +14,10 @@ module ActiveRecord
         connection.type_cast_from_column(column, value)
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
+      private
         attr_reader :table_name
         delegate :connection, to: :@klass
 
-      private
-
         def column_for(attribute_name)
           if connection.schema_cache.data_source_exists?(table_name)
             connection.schema_cache.columns_hash(table_name)[attribute_name.to_s]

data/lib/active_record/type_caster/map.rb

@@ -13,10 +13,7 @@ module ActiveRecord
         type.serialize(value)
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
+      private
         attr_reader :types
     end
   end

data/lib/active_record/validations/uniqueness.rb

@@ -56,33 +56,21 @@ module ActiveRecord
       end
 
       def build_relation(klass, attribute, value)
-        if reflection = klass._reflect_on_association(attribute)
-          attribute = reflection.foreign_key
-          value = value.attributes[reflection.klass.primary_key] unless value.nil?
-        end
-
-        if value.nil?
-          return klass.unscoped.where!(attribute => value)
-        end
-
-        # the attribute may be an aliased attribute
-        if klass.attribute_alias?(attribute)
-          attribute = klass.attribute_alias(attribute)
+        relation = klass.unscoped
+        comparison = relation.bind_attribute(attribute, value) do |attr, bind|
+          return relation.none! if bind.unboundable?
+
+          if bind.nil?
+            attr.eq(bind)
+          elsif options[:case_sensitive]
+            klass.connection.case_sensitive_comparison(attr, bind)
+          else
+            # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
+            klass.connection.case_insensitive_comparison(attr, bind)
+          end
         end
 
-        attribute_name = attribute.to_s
-        value = klass.predicate_builder.build_bind_attribute(attribute_name, value)
-
-        table = klass.arel_table
-        column = klass.columns_hash[attribute_name]
-
-        comparison = if !options[:case_sensitive]
-          # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
-          klass.connection.case_insensitive_comparison(table, attribute, column, value)
-        else
-          klass.connection.case_sensitive_comparison(table, attribute, column, value)
-        end
-        klass.unscoped.where!(comparison)
+        relation.where!(comparison)
       end
 
       def scope_relation(record, relation)

data/lib/active_record.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #--
-# Copyright (c) 2004-2018 David Heinemeier Hansson
+# Copyright (c) 2004-2019 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -163,6 +163,7 @@ module ActiveRecord
       "active_record/tasks/postgresql_database_tasks"
   end
 
+  autoload :TestDatabases, "active_record/test_databases"
   autoload :TestFixtures, "active_record/fixtures"
 
   def self.eager_load!

data/lib/arel/alias_predication.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module AliasPredication
+    def as(other)
+      Nodes::As.new self, Nodes::SqlLiteral.new(other)
+    end
+  end
+end

data/lib/arel/attributes/attribute.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Attributes
+    class Attribute < Struct.new :relation, :name
+      include Arel::Expressions
+      include Arel::Predications
+      include Arel::AliasPredication
+      include Arel::OrderPredications
+      include Arel::Math
+
+      ###
+      # Create a node for lowering this attribute
+      def lower
+        relation.lower self
+      end
+
+      def type_cast_for_database(value)
+        relation.type_cast_for_database(name, value)
+      end
+
+      def able_to_type_cast?
+        relation.able_to_type_cast?
+      end
+    end
+
+    class String    < Attribute; end
+    class Time      < Attribute; end
+    class Boolean   < Attribute; end
+    class Decimal   < Attribute; end
+    class Float     < Attribute; end
+    class Integer   < Attribute; end
+    class Undefined < Attribute; end
+  end
+
+  Attribute = Attributes::Attribute
+end

data/lib/arel/attributes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "arel/attributes/attribute"
+
+module Arel # :nodoc: all
+  module Attributes
+    ###
+    # Factory method to wrap a raw database +column+ to an Arel Attribute.
+    def self.for(column)
+      case column.type
+      when :string, :text, :binary             then String
+      when :integer                            then Integer
+      when :float                              then Float
+      when :decimal                            then Decimal
+      when :date, :datetime, :timestamp, :time then Time
+      when :boolean                            then Boolean
+      else
+        Undefined
+      end
+    end
+  end
+end

data/lib/arel/collectors/bind.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class Bind
+      def initialize
+        @binds = []
+      end
+
+      def <<(str)
+        self
+      end
+
+      def add_bind(bind)
+        @binds << bind
+        self
+      end
+
+      def value
+        @binds
+      end
+    end
+  end
+end

data/lib/arel/collectors/composite.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class Composite
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def <<(str)
+        left << str
+        right << str
+        self
+      end
+
+      def add_bind(bind, &block)
+        left.add_bind bind, &block
+        right.add_bind bind, &block
+        self
+      end
+
+      def value
+        [left.value, right.value]
+      end
+
+      private
+        attr_reader :left, :right
+    end
+  end
+end

data/lib/arel/collectors/plain_string.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class PlainString
+      def initialize
+        @str = +""
+      end
+
+      def value
+        @str
+      end
+
+      def <<(str)
+        @str << str
+        self
+      end
+    end
+  end
+end

data/lib/arel/collectors/sql_string.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "arel/collectors/plain_string"
+
+module Arel # :nodoc: all
+  module Collectors
+    class SQLString < PlainString
+      def initialize(*)
+        super
+        @bind_index = 1
+      end
+
+      def add_bind(bind)
+        self << yield(@bind_index)
+        @bind_index += 1
+        self
+      end
+    end
+  end
+end

data/lib/arel/collectors/substitute_binds.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Collectors
+    class SubstituteBinds
+      def initialize(quoter, delegate_collector)
+        @quoter = quoter
+        @delegate = delegate_collector
+      end
+
+      def <<(str)
+        delegate << str
+        self
+      end
+
+      def add_bind(bind)
+        self << quoter.quote(bind)
+      end
+
+      def value
+        delegate.value
+      end
+
+      private
+        attr_reader :quoter, :delegate
+    end
+  end
+end