switchman 3.6.8 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c258da7abce6b4b34bb1dac83e352aeb4548776a34820969460c31b4c61674e
-  data.tar.gz: '0512961dad99c3041d461ed8e6e183a998d70cd4229712b7246099e8c408c139'
+  metadata.gz: bd3fc41cd455d5855db84fd49d132dca58c824dbe50e49ea4ab7c4cd0ee24d00
+  data.tar.gz: df1df2b43f521a5b5e424165ac167d2de351c4800db6fe50b5d83a78e8e17e16
 SHA512:
-  metadata.gz: 494681d5982a2035e85f3058162a7864b1afc89df2c29ba0d95d99bc9408fabe23b4f762b706946152a3f5e983320bf0c2704c0cc66ad13367ae062c9d20843f
-  data.tar.gz: ce04f224bd153d4de41df5d2b8ec28b22c25e591eb6465ffcf6e8c1a5e831992981a6fc8c8e86130914ca5d91c6442c2b4335c76f374b61ae24bfc21ad838adc
+  metadata.gz: 5b721c57764dc47c2da10b027b63fdeed4795c349b2dec36b0d440e98ff0294355a4bbb03d2176f30883de0b842e2f4a47f27ea2fa2f56405594f53d4a278f6c
+  data.tar.gz: 2729dfb39b1e3d8e3df84bcf1bd321ac39de73e552d8a6c0f15f48f6b9fdb47611a076f8e11fbcbfeb4fd8097c2e6a49a2eab7d76942af92ed769c03b1b9f7d0

data/lib/switchman/active_record/associations.rb

@@ -203,41 +203,7 @@ module Switchman
             # #compare_by_identity makes such owners different hash keys
             @records_by_owner = {}.compare_by_identity
 
-            if ::Rails.version >= "7.0"
-              raw_records ||= loader_query.records_for([self])
-            elsif owner_keys.empty?
-              raw_records ||= []
-            else
-              # determine the shard to search for each owner
-              if reflection.macro == :belongs_to
-                # for belongs_to, it's the shard of the foreign_key
-                partition_proc = lambda do |owner|
-                  if owner.class.sharded_column?(owner_key_name)
-                    Shard.shard_for(owner[owner_key_name], owner.shard)
-                  else
-                    Shard.current
-                  end
-                end
-              elsif !reflection.options[:multishard]
-                # for non-multishard associations, it's *just* the owner's shard
-                partition_proc = ->(owner) { owner.shard }
-              end
-
-              raw_records ||= Shard.partition_by_shard(owners, partition_proc) do |partitioned_owners|
-                relative_owner_keys = partitioned_owners.map do |owner|
-                  key = owner[owner_key_name]
-                  if key && owner.class.sharded_column?(owner_key_name)
-                    key = Shard.relative_id_for(key,
-                                                owner.shard,
-                                                Shard.current(klass.connection_class_for_self))
-                  end
-                  convert_key(key)
-                end
-                relative_owner_keys.compact!
-                relative_owner_keys.uniq!
-                records_for(relative_owner_keys)
-              end
-            end
+            raw_records ||= loader_query.records_for([self])
 
             @preloaded_records = raw_records.select do |record|
               assignments = false

data/lib/switchman/active_record/attribute_methods.rb

@@ -26,10 +26,10 @@ module Switchman
         end
 
         def define_attribute_methods
-          super
+          result = super
           # ensure that we're using the sharded attribute method
           # and not the silly one in AR::AttributeMethods::PrimaryKey
-          return unless sharded_column?(@primary_key)
+          return result unless sharded_column?(@primary_key)
 
           class_eval(
             build_sharded_getter("id",
@@ -41,6 +41,7 @@ module Switchman
           class_eval(build_sharded_setter("id", @primary_key, "::#{connection_class_for_self.name}"),
                      __FILE__,
                      __LINE__)
+          result
         end
 
         protected
@@ -55,19 +56,20 @@ module Switchman
         end
 
         def define_cached_method(owner, name, namespace:, as:, &block)
-          if ::Rails.version < "7.0"
-            yield owner
-            owner.rename_method(as, name)
+          if ::Rails.version < "7.1.4"
+            # https://github.com/rails/rails/commit/a2a12fc2e3f4e6d06f81d4c74c88f8e6b3369ee6#diff-5b59ece6d9396b596f06271cec0ea726e3360911383511c49b1a66f454bfc2b6L30
+            # These arguments were effectively swapped in Rails 7.1.4, so previous versions need them reversed
+            owner.define_cached_method(as, namespace: namespace, as: name, &block)
           else
             owner.define_cached_method(name, namespace: namespace, as: as, &block)
           end
         end
 
-        def define_method_global_attribute(attr_name, owner:)
+        def define_method_global_attribute(attr_name, owner:, as: attr_name)
           if sharded_column?(attr_name)
             define_cached_method(owner,
-                                 "global_#{attr_name}",
-                                 as: "sharded_global_#{attr_name}",
+                                 "sharded_global_#{attr_name}",
+                                 as: "global_#{as}",
                                  namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def sharded_global_#{attr_name}
@@ -84,11 +86,11 @@ module Switchman
           end
         end
 
-        def define_method_local_attribute(attr_name, owner:)
+        def define_method_local_attribute(attr_name, owner:, as: attr_name)
           if sharded_column?(attr_name)
             define_cached_method(owner,
-                                 "local_#{attr_name}",
-                                 as: "sharded_local_#{attr_name}",
+                                 "sharded_local_#{attr_name}",
+                                 as: "local_#{as}",
                                  namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def sharded_local_#{attr_name}
@@ -127,21 +129,21 @@ module Switchman
           end
         end
 
-        def define_method_attribute(attr_name, owner:)
+        def define_method_attribute(attr_name, owner:, as: attr_name)
           if sharded_column?(attr_name)
             reflection = reflection_for_integer_attribute(attr_name)
             class_name = connection_class_for_self_code_for_reflection(reflection)
             safe_class_name = class_name.unpack1("h*")
             define_cached_method(owner,
-                                 attr_name,
-                                 as: "sharded_#{safe_class_name}_#{attr_name}",
+                                 "sharded_#{safe_class_name}_#{attr_name}",
+                                 as: as,
                                  namespace: :switchman) do |batch|
               batch << build_sharded_getter("sharded_#{safe_class_name}_#{attr_name}",
-                                            "original_#{attr_name}",
+                                            "original_#{as}",
                                             class_name)
             end
           else
-            define_cached_method(owner, attr_name, as: "plain_#{attr_name}", namespace: :switchman) do |batch|
+            define_cached_method(owner, "plain_#{attr_name}", as: as, namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def plain_#{attr_name}
                   _read_attribute("#{attr_name}") { |n| missing_attribute(n, caller) }
@@ -174,19 +176,19 @@ module Switchman
           RUBY
         end
 
-        def define_method_attribute=(attr_name, owner:)
+        def define_method_attribute=(attr_name, owner:, as: attr_name)
           if sharded_column?(attr_name)
             reflection = reflection_for_integer_attribute(attr_name)
             class_name = connection_class_for_self_code_for_reflection(reflection)
             safe_class_name = class_name.unpack1("h*")
             define_cached_method(owner,
-                                 "#{attr_name}=",
-                                 as: "sharded_#{safe_class_name}_#{attr_name}=",
+                                 "sharded_#{safe_class_name}_#{attr_name}=",
+                                 as: "#{as}=",
                                  namespace: :switchman) do |batch|
               batch << build_sharded_setter("sharded_#{safe_class_name}_#{attr_name}", attr_name, class_name)
             end
           else
-            define_cached_method(owner, "#{attr_name}=", as: "plain_#{attr_name}=", namespace: :switchman) do |batch|
+            define_cached_method(owner, "plain_#{attr_name}=", as: "#{as}=", namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def plain_#{attr_name}=(new_value)
                   _write_attribute('#{attr_name}', new_value)
@@ -204,11 +206,11 @@ module Switchman
           RUBY
         end
 
-        def define_method_original_attribute(attr_name, owner:)
+        def define_method_original_attribute(attr_name, owner:, as: attr_name)
           if sharded_column?(attr_name)
             define_cached_method(owner,
-                                 "original_#{attr_name}",
-                                 as: "sharded_original_#{attr_name}",
+                                 "sharded_original_#{attr_name}",
+                                 as: "original_#{as}",
                                  namespace: :switchman) do |batch|
               batch << <<-RUBY
                 def sharded_original_#{attr_name}
@@ -221,12 +223,12 @@ module Switchman
           end
         end
 
-        def define_method_original_attribute=(attr_name, owner:)
+        def define_method_original_attribute=(attr_name, owner:, as: attr_name)
           return unless sharded_column?(attr_name)
 
           define_cached_method(owner,
-                               "original_#{attr_name}=",
-                               as: "sharded_original_#{attr_name}=",
+                               "sharded_original_#{attr_name}=",
+                               as: "original_#{as}=",
                                namespace: :switchman) do |batch|
             batch << <<-RUBY
               def sharded_original_#{attr_name}=(new_value)
@@ -240,8 +242,8 @@ module Switchman
           return if columns_hash["#{prefix}_#{attr_name}"] || attr_name == "id"
 
           define_cached_method(owner,
-                               "#{prefix}_#{attr_name}",
-                               as: "unsharded_#{prefix}_#{attr_name}",
+                               "unsharded_#{prefix}_#{attr_name}",
+                               as: "#{prefix}_#{attr_name}",
                                namespace: :switchman) do |batch|
             batch << <<-RUBY
               def unsharded_#{prefix}_#{attr_name}

data/lib/switchman/active_record/base.rb

@@ -136,11 +136,7 @@ module Switchman
         end
 
         def connected_to_stack
-          has_own_stack = if ::Rails.version < "7.0"
-                            Thread.current.thread_variable?(:ar_connected_to_stack)
-                          else
-                            ::ActiveSupport::IsolatedExecutionState.key?(:active_record_connected_to_stack)
-                          end
+          has_own_stack = ::ActiveSupport::IsolatedExecutionState.key?(:active_record_connected_to_stack)
 
           ret = super
           return ret if has_own_stack
@@ -189,12 +185,6 @@ module Switchman
 
           Shard.default
         end
-
-        if ::Rails.version < "7.0"
-          def connection_class_for_self
-            connection_classes
-          end
-        end
       end
 
       def self.prepended(klass)

data/lib/switchman/active_record/calculations.rb

@@ -148,19 +148,10 @@ module Switchman
       private
 
       def type_cast_calculated_value_switchman(value, column_name, operation)
-        if ::Rails.version < "7.0"
-          type_cast_calculated_value(value, operation) do |val|
-            column = aggregate_column(column_name)
-            type ||= column.try(:type_caster) ||
-                     lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
-            type.deserialize(val)
-          end
-        else
-          column = aggregate_column(column_name)
-          type ||= column.try(:type_caster) ||
-                   lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
-          type_cast_calculated_value(value, operation, type)
-        end
+        column = aggregate_column(column_name)
+        type ||= column.try(:type_caster) ||
+                 lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
+        type_cast_calculated_value(value, operation, type)
       end
 
       def column_name_for(field)

data/lib/switchman/active_record/connection_pool.rb

@@ -60,7 +60,7 @@ module Switchman
       private
 
       def current_shard
-        (::Rails.version < "7.0") ? connection_klass.current_switchman_shard : connection_class.current_switchman_shard
+        connection_class.current_switchman_shard
       end
 
       def tls_key

data/lib/switchman/active_record/relation.rb

@@ -55,7 +55,7 @@ module Switchman
       end
 
       def load(&block)
-        if !loaded? || (::Rails.version >= "7.0" && scheduled?)
+        if !loaded? || scheduled?
           @records = activate { |relation| relation.send(:exec_queries, &block) }
           @loaded = true
         end

data/lib/switchman/engine.rb

@@ -10,20 +10,9 @@ module Switchman
 
     ::GuardRail.singleton_class.prepend(GuardRail::ClassMethods)
 
-    # after :initialize_dependency_mechanism to ensure autoloading is
-    # configured for any downstream initializers that care. In rails 7.0 we
-    # should be able to just use an explicit after on configuring the once
-    # autoloaders and not need to go monkey around with initializer order
-    if ::Rails.version < "7.0"
-      initialize_dependency_mechanism = ::Rails::Application::Bootstrap.initializers.find do |i|
-        i.name == :initialize_dependency_mechanism
-      end
-      initialize_dependency_mechanism.instance_variable_get(:@options)[:after] = :set_autoload_paths
-    end
-
     initializer "switchman.active_record_patch",
                 before: "active_record.initialize_database",
-                after: ((::Rails.version < "7.0") ? :initialize_dependency_mechanism : :setup_once_autoloader) do
+                after: :setup_once_autoloader do
       ::ActiveSupport.on_load(:active_record) do
         # Switchman requires postgres, so just always load the pg adapter
         require "active_record/connection_adapters/postgresql_adapter"
@@ -54,11 +43,9 @@ module Switchman
         ::ActiveRecord::Associations::CollectionProxy.include(ActiveRecord::Associations::CollectionProxy)
 
         ::ActiveRecord::Associations::Preloader::Association.prepend(ActiveRecord::Associations::Preloader::Association)
-        unless ::Rails.version < "7.0"
-          ::ActiveRecord::Associations::Preloader::Association::LoaderRecords.prepend(
-            ActiveRecord::Associations::Preloader::Association::LoaderRecords
-          )
-        end
+        ::ActiveRecord::Associations::Preloader::Association::LoaderRecords.prepend(
+          ActiveRecord::Associations::Preloader::Association::LoaderRecords
+        )
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::AbstractAdapter)
         unless ::Rails.version < "7.1"
           ::ActiveRecord::ConnectionAdapters::ConnectionHandler.prepend(ActiveRecord::ConnectionHandler)

data/lib/switchman/sharded_instrumenter.rb

@@ -16,11 +16,7 @@ module Switchman
         payload[:shard] = {
           database_server_id: shard.database_server.id,
           id: shard.id,
-          env: if ::Rails.version < "7.0"
-                 @shard_host.pool.connection_klass&.current_role
-               else
-                 @shard_host.pool.connection_class&.current_role
-               end
+          env: @shard_host.pool.connection_class&.current_role
         }
       end
       super(name, payload)

data/lib/switchman/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Switchman
-  VERSION = "3.6.8"
+  VERSION = "4.0.1"
 end

data/lib/tasks/switchman.rake

@@ -1,16 +1,5 @@
 # frozen_string_literal: true
 
-# In rails 7.0+ if you have only 1 db in the env it doesn't try to do explicit activation
-# (and for rails purposes we only have one db per env because each database server is a separate env)
-if Rails.version < "7.0"
-  task_prefix = Rake::Task.task_defined?("app:db:migrate") ? "app:db" : "db"
-  Rake::Task["#{task_prefix}:migrate"].clear_actions.enhance do
-    ActiveRecord::Tasks::DatabaseTasks.migrate
-    # Ensure this doesn't blow up when running inside the dummy app
-    Rake::Task["#{task_prefix}:_dump"].invoke
-  end
-end
-
 module Switchman
   module Rake
     def self.filter_database_servers
@@ -265,28 +254,9 @@ module Switchman
 
   module ActiveRecord
     module PostgreSQLDatabaseTasks
-      if ::Rails.version < "7.0"
-        def structure_dump(filename, extra_flags = nil)
-          set_psql_env
-          args = ["--schema-only", "--no-privileges", "--no-owner", "--file", filename]
-          args.concat(Array(extra_flags)) if extra_flags
-          shard = Shard.current.name
-          serialized_search_path = shard
-          args << "--schema=#{Shellwords.escape(shard)}"
-
-          ignore_tables = ::ActiveRecord::SchemaDumper.ignore_tables
-          args += ignore_tables.flat_map { |table| ["-T", table] } if ignore_tables.any?
-
-          args << db_config.database
-          run_cmd("pg_dump", args, "dumping")
-          remove_sql_header_comments(filename)
-          File.open(filename, "a") { |f| f << "SET search_path TO #{serialized_search_path};\n\n" }
-        end
-      else
-        def structure_dump(...)
-          ::ActiveRecord.dump_schemas = Switchman::Shard.current.name
-          super
-        end
+      def structure_dump(...)
+        ::ActiveRecord.dump_schemas = Switchman::Shard.current.name
+        super
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: switchman
 version: !ruby/object:Gem::Version
-  version: 3.6.8
+  version: 4.0.1
 platform: ruby
 authors:
 - Cody Cutrer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-01-27 00:00:00.000000000 Z
+date: 2025-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.4
+        version: '7.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '7.2'
@@ -28,7 +28,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.1.4
+        version: '7.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '7.2'
@@ -66,7 +66,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '7.2'
@@ -76,7 +76,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '7.2'