active_record_shards 3.19.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24b77105aa8df10b1e79313f01b54fe87dba293938c9d41dc103f41cac64ec84
-  data.tar.gz: ec1da959a6dc2adbb6f287f73a3346c68fd49db30f7922dbc9adca7368532af2
+  metadata.gz: 07a2ae4e9b397abcc455655266c9d66c76af160e56ea963b401a130589f3f48c
+  data.tar.gz: 45993e917fb0585637c72f89d6bee77f805e0192efb6ca3f476e86929d9192ab
 SHA512:
-  metadata.gz: 5ccae049b9c4a450f04cc2ae6b0cfca9eba75ac72d5f795c0c49ae5fc19e37fad1341d14f3ba34f75c684696131586a663fb306bcd35c2dad9fc625ad36955f3
-  data.tar.gz: 0b46d1cafa4fecae447a01106bfc4de592b7271fc17fef4c254a44a80cc22b22f5155e460d6aba036baad1a229f6f0b6935c3d108c935c5fd5cec9e6271eab83
+  metadata.gz: 16309006259fadb5b3851ea470d8859618c2df4d10555e5ecb50c257d538ac3f36c69490a33547bc7e53e6a2962d5985623176021b5f0866f9a35973138000cc
+  data.tar.gz: d23f2ae22180be953ba4a8bbb23000f73901ecf7950cae95858d371eec24bf01f2e7d6ee0c7225e8bbe2f76490261baae4059193718ae3cb17ffd78ab338f852

data/README.md

@@ -5,7 +5,7 @@
 ActiveRecord Shards is an extension for ActiveRecord that provides support for sharded database and replicas. Basically it is just a nice way to
 switch between database connections. We've made the implementation very small, and have tried not to reinvent any wheels already present in ActiveRecord.
 
-ActiveRecord Shards has been used and tested on Rails 4.2, 5.x and 6.0, and has in some form or another been used in production on large Rails apps for several years.
+ActiveRecord Shards has been used and tested on Rails 5.x and 6.0, and has in some form or another been used in production on large Rails apps for several years.
 
 - [Installation](#installation)
 - [Configuration](#configuration)
@@ -148,12 +148,16 @@ ActiveRecord::Base.on_replica do
 end
 ```
 
-This will perform the query on the replica, and mark the returned instances as read only. There is also a shortcut for this:
+This will perform the query on the replica, and mark the returned instances as read-only. There is also a shortcut for this:
 
 ```ruby
 Account.on_replica.find_by_big_expensive_query
 ```
 
+If you do not want instances returned from replicas to be marked as read-only, this can be disabled globally:
+
+`ActiveRecordShards.disable_replica_readonly_records = true`
+
 ## Debugging
 
 Show if a query went to primary or replica in the logs:

data/lib/active_record_shards/association_collection_connection_selection.rb

@@ -5,32 +5,26 @@ module ActiveRecordShards
     def on_replica_if(condition)
       condition ? on_replica : self
     end
-    alias_method :on_slave_if, :on_replica_if
 
     def on_replica_unless(condition)
       on_replica_if(!condition)
     end
-    alias_method :on_slave_unless, :on_replica_unless
 
     def on_primary_if(condition)
       condition ? on_primary : self
     end
-    alias_method :on_master_if, :on_primary_if
 
     def on_primary_unless(condition)
       on_primary_if(!condition)
     end
-    alias_method :on_master_unless, :on_primary_unless
 
     def on_replica
       PrimaryReplicaProxy.new(self, :replica)
     end
-    alias_method :on_slave, :on_replica
 
     def on_primary
       PrimaryReplicaProxy.new(self, :primary)
     end
-    alias_method :on_master, :on_primary
 
     class PrimaryReplicaProxy
       def initialize(association_collection, which)
@@ -42,8 +36,7 @@ module ActiveRecordShards
         reflection = @association_collection.proxy_association.reflection
         reflection.klass.on_cx_switch_block(@which) { @association_collection.send(method, *args, &block) }
       end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
     end
-
-    MasterSlaveProxy = PrimaryReplicaProxy
   end
 end

data/lib/active_record_shards/configuration_parser.rb

@@ -28,14 +28,6 @@ module ActiveRecordShards
           expand_child!(env_config, replica_conf)
           conf["#{env_name}_replica"] = replica_conf
         end
-
-        # rubocop:disable Style/Next
-        if legacy_replica_conf = env_config.delete('slave')
-          ActiveRecordShards::Deprecation.warn('`slave` configuration keys should be replaced with `replica` keys!')
-          expand_child!(env_config, legacy_replica_conf)
-          conf["#{env_name}_replica"] = legacy_replica_conf
-        end
-        # rubocop:enable Style/Next
       end
 
       conf
@@ -43,7 +35,7 @@ module ActiveRecordShards
 
     def expand_child!(parent, child)
       parent.each do |key, value|
-        unless ['slave', 'replica', 'shards'].include?(key) || value.is_a?(Hash)
+        unless ['replica', 'shards'].include?(key) || value.is_a?(Hash)
           child[key] ||= value
         end
       end

data/lib/active_record_shards/connection_switcher-5-1.rb

@@ -4,7 +4,7 @@ module ActiveRecordShards
       name = current_shard_selection.resolve_connection_name(sharded: is_sharded?, configurations: configurations)
 
       unless configurations[name] || name == "primary"
-        raise ActiveRecord::AdapterNotSpecified, "No database defined by #{name} in your database config. (configurations: #{configurations.keys.inspect})"
+        raise ActiveRecord::AdapterNotSpecified, "No database defined by #{name} in your database config. (configurations: #{configurations.to_h.keys.inspect})"
       end
 
       name

data/lib/active_record_shards/{connection_switcher-5-0.rb → connection_switcher-6-0.rb}

@@ -3,8 +3,13 @@ module ActiveRecordShards
     def connection_specification_name
       name = current_shard_selection.resolve_connection_name(sharded: is_sharded?, configurations: configurations)
 
-      unless configurations[name] || name == "primary"
-        raise ActiveRecord::AdapterNotSpecified, "No database defined by #{name} in your database config. (configurations: #{configurations.keys.inspect})"
+      @_ars_connection_specification_names ||= {}
+      unless @_ars_connection_specification_names.include?(name)
+        unless configurations[name] || name == "primary"
+          raise ActiveRecord::AdapterNotSpecified, "No database defined by #{name} in your database config. (configurations: #{configurations.to_h.keys.inspect})"
+        end
+
+        @_ars_connection_specification_names[name] = true
       end
 
       name
@@ -19,11 +24,7 @@ module ActiveRecordShards
       spec_name = connection_specification_name
 
       pool = connection_handler.retrieve_connection_pool(spec_name)
-      if pool.nil?
-        resolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(configurations)
-        spec = resolver.spec(spec_name.to_sym, spec_name)
-        connection_handler.establish_connection(spec)
-      end
+      connection_handler.establish_connection(spec_name.to_sym) if pool.nil?
     end
   end
 end

data/lib/active_record_shards/connection_switcher.rb

@@ -7,13 +7,8 @@ module ActiveRecordShards
     SHARD_NAMES_CONFIG_KEY = 'shard_names'
 
     def self.extended(base)
-      if ActiveRecord::VERSION::MAJOR >= 5
-        base.singleton_class.send(:alias_method, :load_schema_without_default_shard!, :load_schema!)
-        base.singleton_class.send(:alias_method, :load_schema!, :load_schema_with_default_shard!)
-      else
-        base.singleton_class.send(:alias_method, :columns_without_default_shard, :columns)
-        base.singleton_class.send(:alias_method, :columns, :columns_with_default_shard)
-      end
+      base.singleton_class.send(:alias_method, :load_schema_without_default_shard!, :load_schema!)
+      base.singleton_class.send(:alias_method, :load_schema!, :load_schema_with_default_shard!)
 
       base.singleton_class.send(:alias_method, :table_exists_without_default_shard?, :table_exists?)
       base.singleton_class.send(:alias_method, :table_exists?, :table_exists_with_default_shard?)
@@ -62,22 +57,18 @@ module ActiveRecordShards
     def on_replica_if(condition, &block)
       condition ? on_replica(&block) : yield
     end
-    alias_method :on_slave_if, :on_replica_if
 
     def on_replica_unless(condition, &block)
       on_replica_if(!condition, &block)
     end
-    alias_method :on_slave_unless, :on_replica_unless
 
     def on_primary_if(condition, &block)
       condition ? on_primary(&block) : yield
     end
-    alias_method :on_master_if, :on_primary_if
 
     def on_primary_unless(condition, &block)
       on_primary_if(!condition, &block)
     end
-    alias_method :on_master_unless, :on_primary_unless
 
     def on_primary_or_replica(which, &block)
       if block_given?
@@ -86,7 +77,6 @@ module ActiveRecordShards
         PrimaryReplicaProxy.new(self, which)
       end
     end
-    alias_method :on_master_or_slave, :on_primary_or_replica
 
     # Executes queries using the replica database. Fails over to primary if no replica is found.
     # if you want to execute a block of code on the replica you can go:
@@ -100,23 +90,14 @@ module ActiveRecordShards
     def on_replica(&block)
       on_primary_or_replica(:replica, &block)
     end
-    alias_method :on_slave, :on_replica
 
     def on_primary(&block)
       on_primary_or_replica(:primary, &block)
     end
-    alias_method :on_master, :on_primary
-
-    # just to ease the transition from replica to active_record_shards
-    alias_method :with_slave, :on_replica
-    alias_method :with_slave_if, :on_replica_if
-    alias_method :with_slave_unless, :on_replica_unless
 
     def on_cx_switch_block(which, force: false, construct_ro_scope: nil, &block)
       @disallow_replica ||= 0
-      @disallow_replica += 1 if [:primary, :master].include?(which)
-
-      ActiveRecordShards::Deprecation.warn('the `:master` option should be replaced with `:primary`!') if which == :master
+      @disallow_replica += 1 if which == :primary
 
       switch_to_replica = force || @disallow_replica.zero?
       old_options = current_shard_selection.options
@@ -125,13 +106,13 @@ module ActiveRecordShards
 
       # we avoid_readonly_scope to prevent some stack overflow problems, like when
       # .columns calls .with_scope which calls .columns and onward, endlessly.
-      if self == ActiveRecord::Base || !switch_to_replica || construct_ro_scope == false
+      if self == ActiveRecord::Base || !switch_to_replica || construct_ro_scope == false || ActiveRecordShards.disable_replica_readonly_records == true
         yield
       else
         readonly.scoping(&block)
       end
     ensure
-      @disallow_replica -= 1 if [:primary, :master].include?(which)
+      @disallow_replica -= 1 if which == :primary
       switch_connection(old_options) if old_options
     end
 
@@ -142,7 +123,6 @@ module ActiveRecordShards
     def on_replica?
       current_shard_selection.on_replica?
     end
-    alias_method :on_slave?, :on_replica?
 
     def current_shard_selection
       Thread.current[:shard_selection] ||= ShardSelection.new
@@ -153,18 +133,27 @@ module ActiveRecordShards
     end
 
     def shard_names
-      unless config = configurations[shard_env]
-        raise "Did not find #{shard_env} in configurations, did you forget to add it to your database config? (configurations: #{configurations.keys.inspect})"
-      end
-      unless config.fetch(SHARD_NAMES_CONFIG_KEY, []).all? { |shard_name| shard_name.is_a?(Integer) }
-        raise "All shard names must be integers: #{config[SHARD_NAMES_CONFIG_KEY].inspect}."
+      unless config_for_env.fetch(SHARD_NAMES_CONFIG_KEY, []).all? { |shard_name| shard_name.is_a?(Integer) }
+        raise "All shard names must be integers: #{config_for_env[SHARD_NAMES_CONFIG_KEY].inspect}."
       end
 
-      config[SHARD_NAMES_CONFIG_KEY] || []
+      config_for_env[SHARD_NAMES_CONFIG_KEY] || []
     end
 
     private
 
+    def config_for_env
+      @_ars_config_for_env ||= {}
+      @_ars_config_for_env[shard_env] ||= begin
+        unless config = configurations[shard_env]
+          raise "Did not find #{shard_env} in configurations, did you forget to add it to your database config? (configurations: #{configurations.to_h.keys.inspect})"
+        end
+
+        config
+      end
+    end
+    alias_method :check_config_for_env, :config_for_env
+
     def switch_connection(options)
       if options.any?
         if options.key?(:replica)
@@ -172,9 +161,7 @@ module ActiveRecordShards
         end
 
         if options.key?(:shard)
-          unless configurations[shard_env]
-            raise "Did not find #{shard_env} in configurations, did you forget to add it to your database config? (configurations: #{configurations.keys.inspect})"
-          end
+          check_config_for_env
 
           current_shard_selection.shard = options[:shard]
         end
@@ -184,7 +171,7 @@ module ActiveRecordShards
     end
 
     def shard_env
-      ActiveRecordShards.rails_env
+      ActiveRecordShards.app_env
     end
 
     # Make these few schema related methods available before having switched to
@@ -197,14 +184,8 @@ module ActiveRecordShards
       end
     end
 
-    if ActiveRecord::VERSION::MAJOR >= 5
-      def load_schema_with_default_shard!
-        with_default_shard { load_schema_without_default_shard! }
-      end
-    else
-      def columns_with_default_shard
-        with_default_shard { columns_without_default_shard }
-      end
+    def load_schema_with_default_shard!
+      with_default_shard { load_schema_without_default_shard! }
     end
 
     def table_exists_with_default_shard?
@@ -220,19 +201,16 @@ module ActiveRecordShards
       def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
         @target.on_primary_or_replica(@which) { @target.send(method, *args, &block) }
       end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
     end
-
-    MasterSlaveProxy = PrimaryReplicaProxy
   end
 end
 
 case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
-when '4.2'
-  require 'active_record_shards/connection_switcher-4-2'
-when '5.0'
-  require 'active_record_shards/connection_switcher-5-0'
-when '5.1', '5.2', '6.0'
+when '5.1', '5.2'
   require 'active_record_shards/connection_switcher-5-1'
+when '6.0'
+  require 'active_record_shards/connection_switcher-6-0'
 else
   raise "ActiveRecordShards is not compatible with #{ActiveRecord::VERSION::STRING}"
 end

data/lib/active_record_shards/default_replica_patches.rb

@@ -22,21 +22,13 @@ module ActiveRecordShards
               #{method}_without_default_replica#{punctuation}(*args, &block)
             end
           end
-
+          ruby2_keywords(:#{method}_with_default_replica#{punctuation}) if respond_to?(:ruby2_keywords, true)
           alias_method :#{method}_without_default_replica#{punctuation}, :#{method}#{punctuation}
           alias_method :#{method}#{punctuation}, :#{method}_with_default_replica#{punctuation}
         #{class_method ? 'end' : ''}
       RUBY
     end
 
-    def self.wrap_method_in_on_slave(*args)
-      ActiveRecordShards::Deprecation.deprecation_warning(
-        :'self.wrap_method_in_on_slave',
-        :'self.wrap_method_in_on_replica'
-      )
-      wrap_method_in_on_replica(*args)
-    end
-
     def transaction_with_replica_off(*args, &block)
       if on_replica_by_default?
         begin
@@ -50,14 +42,9 @@ module ActiveRecordShards
         transaction_without_replica_off(*args, &block)
       end
     end
-    alias_method :transaction_with_slave_off, :transaction_with_replica_off
+    ruby2_keywords(:transaction_with_replica_off) if respond_to?(:ruby2_keywords, true)
 
     module InstanceMethods
-      # fix ActiveRecord to do the right thing, and use our aliased quote_value
-      def quote_value(*args, &block)
-        self.class.quote_value(*args, &block)
-      end
-
       def on_replica_unless_tx
         self.class.on_replica_unless_tx { yield }
       end
@@ -84,19 +71,11 @@ module ActiveRecordShards
       :table_exists?
     ].freeze
 
-    CLASS_SLAVE_METHODS = CLASS_REPLICA_METHODS
-    CLASS_FORCE_SLAVE_METHODS = CLASS_FORCE_REPLICA_METHODS
-
     def self.extended(base)
       CLASS_REPLICA_METHODS.each { |m| ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(true, base, m) }
       CLASS_FORCE_REPLICA_METHODS.each { |m| ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(true, base, m, force_on_replica: true) }
 
-      if ActiveRecord::VERSION::MAJOR >= 5
-        ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(true, base, :load_schema!, force_on_replica: true)
-      else
-        ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(true, base, :columns, force_on_replica: true)
-      end
-
+      ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(true, base, :load_schema!, force_on_replica: true)
       ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(false, base, :reload)
 
       base.class_eval do
@@ -119,7 +98,6 @@ module ActiveRecordShards
         yield
       end
     end
-    alias_method :on_slave_unless_tx, :on_replica_unless_tx
 
     def force_on_replica(&block)
       return yield if Thread.current[:_active_record_shards_in_migration]
@@ -133,11 +111,6 @@ module ActiveRecordShards
           ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(false, base, m)
         end
 
-        if ActiveRecord::VERSION::MAJOR == 4
-          # `where` and `having` clauses call `create_binds`, which will use the primary connection
-          ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(false, base, :create_binds, force_on_replica: true)
-        end
-
         ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(false, base, :to_sql, force_on_replica: true)
       end
 
@@ -210,20 +183,6 @@ module ActiveRecordShards
       end
     end
 
-    module AssociationsAssociationGetRecordsPatch
-      def get_records # rubocop:disable Naming/AccessorMethodName
-        if klass
-          on_replica_unless_tx { super }
-        else
-          super
-        end
-      end
-
-      def on_replica_unless_tx
-        klass.on_replica_unless_tx { yield }
-      end
-    end
-
     module AssociationsPreloaderAssociationAssociatedRecordsByOwnerPatch
       def associated_records_by_owner(preloader)
         if klass

data/lib/active_record_shards/migration.rb

@@ -19,11 +19,10 @@ module ActiveRecord
       # manually on the sharded DBs.
       ActiveRecord::Base.on_all_shards do
         ActiveRecord::SchemaMigration.create_table
-        if ActiveRecord::VERSION::MAJOR >= 5
-          ActiveRecord::InternalMetadata.create_table
-        end
+        ActiveRecord::InternalMetadata.create_table
       end
     end
+    ruby2_keywords(:initialize_with_sharding) if respond_to?(:ruby2_keywords, true)
     alias_method :initialize_without_sharding, :initialize
     alias_method :initialize, :initialize_with_sharding
 

data/lib/active_record_shards/model.rb

@@ -34,7 +34,6 @@ module ActiveRecordShards
         end
       end
     end
-    alias_method :on_slave_by_default?, :on_replica_by_default?
 
     def on_replica_by_default=(value)
       if self == ActiveRecord::Base
@@ -43,19 +42,16 @@ module ActiveRecordShards
         base_class.instance_variable_set(:@on_replica_by_default, value)
       end
     end
-    alias_method :on_slave_by_default=, :on_replica_by_default=
 
     module InstanceMethods
       def initialize_shard_and_replica
         @from_replica = !!self.class.current_shard_selection.options[:replica]
         @from_shard = self.class.current_shard_selection.options[:shard]
       end
-      alias_method :initialize_shard_and_slave, :initialize_shard_and_replica
 
       def from_replica?
         @from_replica
       end
-      alias_method :from_slave?, :from_replica?
 
       def from_shard
         @from_shard

data/lib/active_record_shards/shard_selection.rb

@@ -10,64 +10,33 @@ module ActiveRecordShards
       @shard = nil
     end
 
-    if ActiveRecord::VERSION::MAJOR < 5
-
-      def shard(klass = nil)
-        if (@shard || self.class.default_shard) && (klass.nil? || klass.is_sharded?)
-          if @shard == NO_SHARD
-            nil
-          else
-            @shard || self.class.default_shard
-          end
-        end
+    def shard
+      if @shard.nil? || @shard == NO_SHARD
+        nil
+      else
+        @shard || self.class.default_shard
       end
+    end
 
-      def shard_name(klass = nil, try_replica = true)
-        the_shard = shard(klass)
-
-        @shard_names ||= {}
-        @shard_names[ActiveRecordShards.rails_env] ||= {}
-        @shard_names[ActiveRecordShards.rails_env][the_shard] ||= {}
-        @shard_names[ActiveRecordShards.rails_env][the_shard][try_replica] ||= {}
-        @shard_names[ActiveRecordShards.rails_env][the_shard][try_replica][@on_replica] ||= begin
-          s = ActiveRecordShards.rails_env.dup
-          s << "_shard_#{the_shard}" if the_shard
-          s << "_replica"            if @on_replica && try_replica
-          s
-        end
-      end
-
-    else
-
-      def shard
-        if @shard.nil? || @shard == NO_SHARD
-          nil
+    PRIMARY = "primary"
+    def resolve_connection_name(sharded:, configurations:)
+      resolved_shard = sharded ? shard : nil
+      env = ActiveRecordShards.app_env
+
+      @connection_names ||= {}
+      @connection_names[env] ||= {}
+      @connection_names[env][resolved_shard] ||= {}
+      @connection_names[env][resolved_shard][@on_replica] ||= begin
+        name = env.dup
+        name << "_shard_#{resolved_shard}" if resolved_shard
+        if @on_replica && configurations["#{name}_replica"]
+          "#{name}_replica"
         else
-          @shard || self.class.default_shard
-        end
-      end
-
-      PRIMARY = "primary"
-      def resolve_connection_name(sharded:, configurations:)
-        resolved_shard = sharded ? shard : nil
-        env = ActiveRecordShards.rails_env
-
-        @connection_names ||= {}
-        @connection_names[env] ||= {}
-        @connection_names[env][resolved_shard] ||= {}
-        @connection_names[env][resolved_shard][@on_replica] ||= begin
-          name = env.dup
-          name << "_shard_#{resolved_shard}" if resolved_shard
-          if @on_replica && configurations["#{name}_replica"]
-            "#{name}_replica"
-          else
-            # ActiveRecord always names its default connection pool 'primary'
-            # while everything else is named by the configuration name
-            resolved_shard ? name : PRIMARY
-          end
+          # ActiveRecord always names its default connection pool 'primary'
+          # while everything else is named by the configuration name
+          resolved_shard ? name : PRIMARY
         end
       end
-
     end
 
     def shard=(new_shard)
@@ -77,12 +46,10 @@ module ActiveRecordShards
     def on_replica?
       @on_replica
     end
-    alias_method :on_slave?, :on_replica?
 
     def on_replica=(new_replica)
       @on_replica = (new_replica == true)
     end
-    alias_method :on_slave=, :on_replica=
 
     def options
       { shard: @shard, replica: @on_replica }

data/lib/active_record_shards/shard_support.rb

@@ -23,15 +23,14 @@ module ActiveRecordShards
 
       exception = nil
       enum.each do
-        begin
-          record = @scope.find(*find_args)
-          return record if record
-        rescue ActiveRecord::RecordNotFound => e
-          exception = e
-        end
+        record = @scope.find(*find_args)
+        return record if record
+      rescue ActiveRecord::RecordNotFound => e
+        exception = e
       end
       raise exception
     end
+    ruby2_keywords(:find) if respond_to?(:ruby2_keywords, true)
 
     def count
       enum.inject(0) { |accum, _shard| @scope.clone.count + accum }

data/lib/active_record_shards/tasks.rb

@@ -10,7 +10,7 @@ namespace :db do
   desc 'Drops the database for the current RAILS_ENV including shards'
   task drop: :load_config do
     ActiveRecord::Base.configurations.to_h.each do |key, conf|
-      next if !key.start_with?(ActiveRecordShards.rails_env) || key.end_with?("_replica", "_slave")
+      next if !key.start_with?(ActiveRecordShards.app_env) || key.end_with?("_replica")
 
       begin
         ActiveRecordShards::Tasks.root_connection(conf).drop_database(conf['database'])
@@ -31,7 +31,7 @@ namespace :db do
   desc "Create the database defined in config/database.yml for the current RAILS_ENV including shards"
   task create: :load_config do
     ActiveRecord::Base.configurations.to_h.each do |key, conf|
-      next if !key.start_with?(ActiveRecordShards.rails_env) || key.end_with?("_replica", "_slave")
+      next if !key.start_with?(ActiveRecordShards.app_env) || key.end_with?("_replica")
 
       begin
         # MysqlAdapter takes charset instead of encoding in Rails 4.2 or greater
@@ -48,7 +48,7 @@ namespace :db do
         end
       end
     end
-    ActiveRecord::Base.establish_connection(ActiveRecordShards.rails_env.to_sym)
+    ActiveRecord::Base.establish_connection(ActiveRecordShards.app_env.to_sym)
   end
 
   desc "Raises an error if there are pending migrations"
@@ -78,14 +78,12 @@ namespace :db do
   namespace :test do
     desc 'Purges the test databases by dropping and creating'
     task purge: :load_config do |t|
-      begin
-        saved_env = Rails.env
-        Rails.env = 'test'
-        Rake.application.lookup('db:drop', t.scope).execute
-        Rake.application.lookup('db:create', t.scope).execute
-      ensure
-        Rails.env = saved_env
-      end
+      saved_env = Rails.env
+      Rails.env = 'test'
+      Rake.application.lookup('db:drop', t.scope).execute
+      Rake.application.lookup('db:create', t.scope).execute
+    ensure
+      Rails.env = saved_env
     end
   end
 end

data/lib/active_record_shards.rb

@@ -12,10 +12,16 @@ require 'active_record_shards/default_replica_patches'
 require 'active_record_shards/schema_dumper_extension'
 
 module ActiveRecordShards
-  def self.rails_env
+  class << self
+    attr_accessor :disable_replica_readonly_records
+  end
+
+  def self.app_env
     env = Rails.env if defined?(Rails.env)
     env ||= RAILS_ENV if Object.const_defined?(:RAILS_ENV)
     env ||= ENV['RAILS_ENV']
+    env ||= APP_ENV if Object.const_defined?(:APP_ENV)
+    env ||= ENV['APP_ENV']
     env || 'development'
   end
 end
@@ -30,32 +36,6 @@ ActiveRecord::Associations::Builder::HasAndBelongsToMany.include(ActiveRecordSha
 ActiveRecord::SchemaDumper.prepend(ActiveRecordShards::SchemaDumperExtension)
 
 case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
-when '4.2'
-  require 'active_record_shards/patches-4-2'
-
-  # https://github.com/rails/rails/blob/v4.2.11.3/activerecord/lib/active_record/associations/association.rb#L97
-  ActiveRecord::Associations::Association.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationAssociationScopePatch)
-
-  # https://github.com/rails/rails/blob/v4.2.11.3/activerecord/lib/active_record/associations/singular_association.rb#L44-L53
-  ActiveRecord::Associations::SingularAssociation.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationGetRecordsPatch)
-
-  # https://github.com/rails/rails/blob/v4.2.11.3/activerecord/lib/active_record/associations/collection_association.rb#L447-L456
-  ActiveRecord::Associations::CollectionAssociation.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationGetRecordsPatch)
-
-  # https://github.com/rails/rails/blob/v4.2.11.3/activerecord/lib/active_record/associations/preloader/association.rb#L89
-  ActiveRecord::Associations::Preloader::Association.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsPreloaderAssociationAssociatedRecordsByOwnerPatch)
-when '5.0'
-  # https://github.com/rails/rails/blob/v5.0.7/activerecord/lib/active_record/associations/association.rb#L97
-  ActiveRecord::Associations::Association.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationAssociationScopePatch)
-
-  # https://github.com/rails/rails/blob/v5.0.7/activerecord/lib/active_record/associations/singular_association.rb#L56-L65
-  ActiveRecord::Associations::SingularAssociation.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationGetRecordsPatch)
-
-  # https://github.com/rails/rails/blob/v5.0.7/activerecord/lib/active_record/associations/collection_association.rb#L442-L451
-  ActiveRecord::Associations::CollectionAssociation.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationGetRecordsPatch)
-
-  # https://github.com/rails/rails/blob/v5.0.7/activerecord/lib/active_record/associations/preloader/association.rb#L120
-  ActiveRecord::Associations::Preloader::Association.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsPreloaderAssociationLoadRecordsPatch)
 when '5.1'
   # https://github.com/rails/rails/blob/v5.1.7/activerecord/lib/active_record/associations/association.rb#L97
   ActiveRecord::Associations::Association.prepend(ActiveRecordShards::DefaultReplicaPatches::AssociationsAssociationAssociationScopePatch)
@@ -97,45 +77,3 @@ when '6.0'
 else
   raise "ActiveRecordShards is not compatible with #{ActiveRecord::VERSION::STRING}"
 end
-
-require 'active_record_shards/deprecation'
-
-ActiveRecordShards::Deprecation.deprecate_methods(
-  ActiveRecordShards::AssociationCollectionConnectionSelection,
-  on_slave_if: :on_replica_if,
-  on_slave_unless: :on_replica_unless,
-  on_slave: :on_replica,
-  on_master: :on_primary,
-  on_master_if: :on_primary_if,
-  on_master_unless: :on_primary_unless
-)
-
-ActiveRecordShards::Deprecation.deprecate_methods(
-  ActiveRecordShards::ConnectionSwitcher,
-  on_slave_if: :on_replica_if,
-  on_slave_unless: :on_replica_unless,
-  on_master_or_slave: :on_primary_or_replica,
-  on_slave: :on_replica,
-  on_master: :on_primary,
-  on_master_if: :on_primary_if,
-  on_master_unless: :on_primary_unless,
-  on_slave?: :on_replica?
-)
-
-ActiveRecordShards::Deprecation.deprecate_methods(
-  ActiveRecordShards::DefaultReplicaPatches,
-  transaction_with_slave_off: :transaction_with_replica_off,
-  on_slave_unless_tx: :on_replica_unless_tx
-)
-
-ActiveRecordShards::Deprecation.deprecate_methods(
-  ActiveRecordShards::Model,
-  on_slave_by_default?: :on_replica_by_default?,
-  :on_slave_by_default= => :on_replica_by_default=
-)
-
-ActiveRecordShards::Deprecation.deprecate_methods(
-  ActiveRecordShards::ShardSelection,
-  on_slave?: :on_replica?,
-  :on_slave= => :on_replica=
-)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_shards
 version: !ruby/object:Gem::Version
-  version: 3.19.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Benjamin Quorning
@@ -13,7 +13,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-09 00:00:00.000000000 Z
+date: 2022-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -21,7 +21,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.1'
     - - "<"
       - !ruby/object:Gem::Version
         version: '6.1'
@@ -31,7 +31,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.1'
     - - "<"
       - !ruby/object:Gem::Version
         version: '6.1'
@@ -41,7 +41,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.1'
     - - "<"
       - !ruby/object:Gem::Version
         version: '6.1'
@@ -51,7 +51,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.1'
     - - "<"
       - !ruby/object:Gem::Version
         version: '6.1'
@@ -195,19 +195,12 @@ files:
 - lib/active_record_shards.rb
 - lib/active_record_shards/association_collection_connection_selection.rb
 - lib/active_record_shards/configuration_parser.rb
-- lib/active_record_shards/connection_handler.rb
-- lib/active_record_shards/connection_pool.rb
-- lib/active_record_shards/connection_specification.rb
-- lib/active_record_shards/connection_switcher-4-2.rb
-- lib/active_record_shards/connection_switcher-5-0.rb
 - lib/active_record_shards/connection_switcher-5-1.rb
+- lib/active_record_shards/connection_switcher-6-0.rb
 - lib/active_record_shards/connection_switcher.rb
 - lib/active_record_shards/default_replica_patches.rb
-- lib/active_record_shards/default_slave_patches.rb
-- lib/active_record_shards/deprecation.rb
 - lib/active_record_shards/migration.rb
 - lib/active_record_shards/model.rb
-- lib/active_record_shards/patches-4-2.rb
 - lib/active_record_shards/schema_dumper_extension.rb
 - lib/active_record_shards/shard_selection.rb
 - lib/active_record_shards/shard_support.rb
@@ -225,14 +218,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.16
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Simple database switching for ActiveRecord.

data/lib/active_record_shards/connection_handler.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-ActiveRecord::ConnectionAdapters::ConnectionHandler.class_eval do
-  remove_method :retrieve_connection_pool
-  def retrieve_connection_pool(klass)
-    class_to_pool[klass.connection_pool_name] ||= pool_for(klass)
-  end
-end

data/lib/active_record_shards/connection_pool.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecordShards
-  ConnectionPoolNameDecorator = Struct.new(:name)
-
-  # It overrides given connection handler methods (they differ depend on
-  # Rails version).
-  #
-  # It takes the first argument, ActiveRecord::Base object or
-  # String (connection_pool_name), converts it in Struct object and
-  # passes to the original method.
-  #
-  # Example:
-  #   methods_to_override = [:establish_connection, :remove_connection]
-  #   ActiveRecordShards.override_connection_handler_methods(methods_to_override)
-  #
-  def self.override_connection_handler_methods(method_names)
-    method_names.each do |method_name|
-      ActiveRecord::ConnectionAdapters::ConnectionHandler.class_eval do
-        define_method("#{method_name}_with_connection_pool_name") do |*args|
-          unless args[0].is_a? ConnectionPoolNameDecorator
-            name = if args[0].is_a? String
-                     args[0]
-                   else
-                     args[0].connection_pool_name
-                   end
-            args[0] = ConnectionPoolNameDecorator.new(name)
-          end
-          send("#{method_name}_without_connection_pool_name", *args)
-        end
-        alias_method :"#{method_name}_without_connection_pool_name", method_name
-        alias_method method_name, :"#{method_name}_with_connection_pool_name"
-      end
-    end
-  end
-end

data/lib/active_record_shards/connection_specification.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-class << ActiveRecord::Base
-  remove_method :establish_connection if ActiveRecord::VERSION::MAJOR >= 5
-  def establish_connection(spec = ENV["DATABASE_URL"])
-    spec ||= ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
-    spec = spec.to_sym if spec.is_a?(String)
-    resolver = ActiveRecordShards::ConnectionSpecification::Resolver.new configurations
-    spec = resolver.spec(spec)
-
-    unless respond_to?(spec.adapter_method)
-      raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
-    end
-
-    remove_connection
-    specification_cache[connection_pool_name] = spec
-    connection_handler.establish_connection self, spec
-  end
-end

data/lib/active_record_shards/connection_switcher-4-2.rb

@@ -1,56 +0,0 @@
-module ActiveRecordShards
-  module ConnectionSwitcher
-    # Name of the connection pool. Used by ConnectionHandler to retrieve the current connection pool.
-    def connection_pool_name # :nodoc:
-      name = current_shard_selection.shard_name(self)
-
-      # e.g. if "production_replica" is not defined in `Configuration`, fall back to "production"
-      if configurations[name].nil? && on_replica?
-        current_shard_selection.shard_name(self, false)
-      else
-        name
-      end
-    end
-
-    private
-
-    def ensure_shard_connection
-      establish_shard_connection unless connected_to_shard?
-    end
-
-    def establish_shard_connection
-      name = connection_pool_name
-      spec = configurations[name]
-
-      if spec.nil?
-        raise ActiveRecord::AdapterNotSpecified, "No database defined by #{name} in your database config. (configurations: #{configurations.keys.inspect})"
-      end
-
-      specification_cache[name] ||= begin
-        resolver = ActiveRecordShards::ConnectionSpecification::Resolver.new configurations
-        resolver.spec(spec)
-      end
-
-      connection_handler.establish_connection(self, specification_cache[name])
-    end
-
-    def specification_cache
-      @@specification_cache ||= {}
-    end
-
-    # Helper method to clear global state when testing.
-    def clear_specification_cache
-      @@specification_cache = {}
-    end
-
-    def connection_pool_key
-      specification_cache[connection_pool_name]
-    end
-
-    def connected_to_shard?
-      specs_to_pools = Hash[connection_handler.connection_pool_list.map { |pool| [pool.spec, pool] }]
-
-      specs_to_pools.key?(connection_pool_key)
-    end
-  end
-end

data/lib/active_record_shards/default_slave_patches.rb

@@ -1,5 +0,0 @@
-ActiveRecordShards::Deprecation.warn('`DefaultSlavePatches` is deprecated, please use `DefaultReplicaPatches`.')
-
-module ActiveRecordShards
-  DefaultSlavePatches = DefaultReplicaPatches
-end

data/lib/active_record_shards/deprecation.rb

@@ -1,12 +0,0 @@
-module ActiveRecordShards
-  class Deprecation < ActiveSupport::Deprecation
-    # This allows us to define separate deprecation behavior for ActiveRecordShards, but defaults to
-    # the same behavior globally configured with ActiveSupport.
-    #
-    # For example, this allows us to silence our own deprecation warnings in test while still being
-    # able to fail tests for upstream deprecation warnings.
-    def behavior
-      @behavior ||= ActiveSupport::Deprecation.behavior
-    end
-  end
-end

data/lib/active_record_shards/patches-4-2.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_record_shards/connection_pool'
-require 'active_record_shards/connection_handler'
-require 'active_record_shards/connection_specification'
-
-ActiveRecordShards::ConnectionSpecification = ActiveRecord::ConnectionAdapters::ConnectionSpecification
-methods_to_override = [:establish_connection, :remove_connection, :pool_for, :pool_from_any_process_for]
-ActiveRecordShards.override_connection_handler_methods(methods_to_override)