active_record_shards 3.6.0 → 3.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9adfc3476e718a0178c8781868e0ef96fc77bc85
-  data.tar.gz: 678e2b636c88a52d427236523c417b67d32bc3e1
+  metadata.gz: 1dd69ed02637e49d444f17f46112f4353bd38274
+  data.tar.gz: 72b1d921a77e347f093d0591b46a4c0dd088cb4e
 SHA512:
-  metadata.gz: 84e2df24248d209b3dcca3a6942064a84cbfabc2b2ef4afdbad24e4350b5ceca876d84e8ceec00b6821cca4c939e7aad2313fda4e06e39df0164c1dc997c188f
-  data.tar.gz: 678577457e7212e8b36c5498c0c5416a781fa0bffc31d49cd36085b0f6f4a1d7d9b09f592a13944a2df815b06578ae00d14827c704f8529cf7961267e926fb03
+  metadata.gz: 25977dee6f8cd3188d6e7577c987a86c30e22b0ac2ee327dd9dccb07fb38bbe925c138497fc15caa1252fe6320cf849740d208abf09a04f8ee0deee2a654adf6
+  data.tar.gz: 000d3325d3934d6b3c4655860edfe512970a0eceac91236dc4064eb9fa5775652df3e283bba0fb232b18c08a40eaada26c1c66b93d3344e70193b971da7e3b59

data/lib/active_record_shards.rb

@@ -33,11 +33,11 @@ if ActiveRecord.const_defined?(:Relation)
 end
 
 if ActiveRecord::Associations.const_defined?(:Preloader) && ActiveRecord::Associations::Preloader.const_defined?(:HasAndBelongsToMany)
-  ActiveRecord::Associations::Preloader::HasAndBelongsToMany.send(:prepend, ActiveRecordShards::DefaultSlavePatches::HasAndBelongsToManyPreloaderPatches)
+  ActiveRecord::Associations::Preloader::HasAndBelongsToMany.send(:include, ActiveRecordShards::DefaultSlavePatches::HasAndBelongsToManyPreloaderPatches)
 end
 
 if ActiveRecord::VERSION::STRING >= '4.1.0'
-  ActiveRecord::Associations::Builder::HasAndBelongsToMany.send(:prepend, ActiveRecordShards::DefaultSlavePatches::Rails41HasAndBelongsToManyBuilderExtension)
+  ActiveRecord::Associations::Builder::HasAndBelongsToMany.send(:include, ActiveRecordShards::DefaultSlavePatches::Rails41HasAndBelongsToManyBuilderExtension)
 end
 
 ActiveRecord::Associations::CollectionProxy.send(:include, ActiveRecordShards::AssociationCollectionConnectionSelection)
@@ -53,17 +53,17 @@ module ActiveRecordShards
     env ||= ENV['RAILS_ENV']
     env ||= 'development'
   end
+end
 
-  module ActiveRecordConnectionPoolName
-    def establish_connection(spec = nil)
-      case spec
-      when ActiveRecordShards::ConnectionSpecification
-        connection_handler.establish_connection(connection_pool_name, spec)
-      else
-        super
-      end
+ActiveRecord::Base.singleton_class.class_eval do
+  def establish_connection_with_connection_pool_name(spec = nil)
+    case spec
+    when ActiveRecordShards::ConnectionSpecification
+      connection_handler.establish_connection(connection_pool_name, spec)
+    else
+      establish_connection_without_connection_pool_name(spec)
     end
   end
+  alias_method :establish_connection_without_connection_pool_name, :establish_connection
+  alias_method :establish_connection, :establish_connection_with_connection_pool_name
 end
-
-ActiveRecord::Base.singleton_class.send(:prepend, ActiveRecordShards::ActiveRecordConnectionPoolName)

data/lib/active_record_shards/configuration_parser.rb

@@ -35,14 +35,15 @@ module ActiveRecordShards
       end
     end
 
-    module PrependMethods
-      def configurations=(conf)
-        super(explode(conf))
-      end
+    def configurations_with_shard_explosion=(conf)
+      self.configurations_without_shard_explosion = explode(conf)
     end
 
     def ConfigurationParser.extended(klass)
-      klass.singleton_class.send(:prepend, PrependMethods)
+      klass.singleton_class.send(:alias_method, :configurations_without_shard_explosion=, :configurations=)
+      klass.singleton_class.send(:alias_method, :configurations=, :configurations_with_shard_explosion=)
+      klass.singleton_class.send(:public, :configurations=)
+
       klass.configurations = klass.configurations if klass.configurations.present?
     end
   end

data/lib/active_record_shards/connection_pool.rb

@@ -13,20 +13,22 @@ module ActiveRecordShards
   #   ActiveRecordShards.override_connection_handler_methods(methods_to_override)
   #
   def self.override_connection_handler_methods(method_names)
-    injected_module = Module.new
     method_names.each do |method_name|
-      injected_module.send(:define_method, method_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)
+      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
-        super(*args)
+        alias_method :"#{method_name}_without_connection_pool_name", method_name
+        alias_method method_name, :"#{method_name}_with_connection_pool_name"
       end
     end
-    ActiveRecord::ConnectionAdapters::ConnectionHandler.send(:prepend, injected_module)
   end
 end

data/lib/active_record_shards/connection_switcher.rb

@@ -4,28 +4,12 @@ module ActiveRecordShards
   module ConnectionSwitcher
     SHARD_NAMES_CONFIG_KEY = 'shard_names'.freeze
 
-    module PrependMethods
-      def columns
-        if is_sharded? && current_shard_id.nil? && table_name != ActiveRecord::Migrator.schema_migrations_table_name
-          on_first_shard { super }
-        else
-          super
-        end
-      end
-
-      def table_exists?
-        result = super()
-
-        if !result && is_sharded? && (shard_name = shard_names.first)
-          result = on_shard(shard_name) { super }
-        end
-
-        result
-      end
-    end
-
     def self.extended(klass)
-      klass.singleton_class.send(:prepend, ActiveRecordShards::ConnectionSwitcher::PrependMethods)
+      klass.singleton_class.send(:alias_method, :columns_without_default_shard, :columns)
+      klass.singleton_class.send(:alias_method, :columns, :columns_with_default_shard)
+
+      klass.singleton_class.send(:alias_method, :table_exists_without_default_shard?, :table_exists?)
+      klass.singleton_class.send(:alias_method, :table_exists?, :table_exists_with_default_shard?)
     end
 
     def default_shard=(new_default_shard)
@@ -234,6 +218,24 @@ module ActiveRecordShards
       specs_to_pools.has_key?(connection_pool_key)
     end
 
+    def columns_with_default_shard
+      if is_sharded? && current_shard_id.nil? && table_name != ActiveRecord::Migrator.schema_migrations_table_name
+        on_first_shard { columns_without_default_shard }
+      else
+        columns_without_default_shard
+      end
+    end
+
+    def table_exists_with_default_shard?
+      result = table_exists_without_default_shard?
+
+      if !result && is_sharded? && (shard_name = shard_names.first)
+        result = on_shard(shard_name) { table_exists_without_default_shard? }
+      end
+
+      result
+    end
+
     def autoload_adapter(adapter_name)
       begin
         require 'rubygems'

data/lib/active_record_shards/default_slave_patches.rb

@@ -9,59 +9,70 @@ module ActiveRecordShards
       end
 
       return unless base_methods.include?(method)
-      injected_module = Module.new
-      injected_module.send(:define_method, method) do |*args, &block|
-        on_slave_unless_tx do
-          super(*args, &block)
-        end
-      end
-      (class_method ? base.singleton_class : base).send(:prepend, injected_module)
+      _, method, punctuation = method.to_s.match(/^(.*?)([\?\!]?)$/).to_a
+      base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        #{class_method ? "class << self" : ""}
+          def #{method}_with_default_slave#{punctuation}(*args, &block)
+            on_slave_unless_tx do
+              #{method}_without_default_slave#{punctuation}(*args, &block)
+            end
+          end
+
+          alias_method :#{method}_without_default_slave#{punctuation}, :#{method}#{punctuation}
+          alias_method :#{method}#{punctuation}, :#{method}_with_default_slave#{punctuation}
+        #{class_method ? "end" : ""}
+      RUBY
     end
 
     CLASS_SLAVE_METHODS = [ :find_by_sql, :count_by_sql,  :calculate, :find_one, :find_some, :find_every, :quote_value, :sanitize_sql_hash_for_conditions, :exists?, :table_exists? ]
 
-    module PrependClassMethods
-      def columns
-        if on_slave_by_default? && !Thread.current[:_active_record_shards_slave_off]
-          read_columns_from = :slave
-        else
-          read_columns_form = :master
-        end
-
-        on_cx_switch_block(read_columns_from, construct_ro_scope: false) { super }
-      end
+    def self.extended(base)
+      CLASS_SLAVE_METHODS.each { |m| ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(true, base, m) }
 
-      def transaction(*args, &block)
-        if on_slave_by_default?
-          old_val = Thread.current[:_active_record_shards_slave_off]
-          Thread.current[:_active_record_shards_slave_off] = true
+      base.class_eval do
+        # 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
 
-        super(*args, &block)
-      ensure
-        if on_slave_by_default?
-          Thread.current[:_active_record_shards_slave_off] = old_val
+        def reload_with_slave_off(*args, &block)
+          self.class.on_master { reload_without_slave_off(*args, &block) }
+        end
+        alias_method :reload_without_slave_off, :reload
+        alias_method :reload, :reload_with_slave_off
+
+        class << self
+          def columns_with_default_slave(*args, &block)
+            if on_slave_by_default? && !Thread.current[:_active_record_shards_slave_off]
+              read_columns_from = :slave
+            else
+              read_columns_form = :master
+            end
+
+            on_cx_switch_block(read_columns_from, :construct_ro_scope => false) { columns_without_default_slave(*args, &block) }
+          end
+          alias_method :columns_without_default_slave, :columns
+          alias_method :columns, :columns_with_default_slave
         end
-      end
-    end
-
-    module PrependMethods
-      # 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 reload(*args, &block)
-        self.class.on_master { super(*args, &block) }
+        class << self
+          def transaction_with_slave_off(*args, &block)
+            if on_slave_by_default?
+              old_val = Thread.current[:_active_record_shards_slave_off]
+              Thread.current[:_active_record_shards_slave_off] = true
+            end
+
+            transaction_without_slave_off(*args, &block)
+          ensure
+            if on_slave_by_default?
+              Thread.current[:_active_record_shards_slave_off] = old_val
+            end
+          end
+
+          alias_method :transaction_without_slave_off, :transaction
+          alias_method :transaction, :transaction_with_slave_off
+        end
       end
-    end
-
-    def self.extended(base)
-      base.send(:prepend, PrependMethods)
-      base.singleton_class.send(:prepend, PrependClassMethods)
-
-      CLASS_SLAVE_METHODS.each { |m| ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(true, base, m) }
-
       if ActiveRecord::Associations.const_defined?(:HasAndBelongsToManyAssociation)
         ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(false, ActiveRecord::Associations::HasAndBelongsToManyAssociation, :construct_sql)
         ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(false, ActiveRecord::Associations::HasAndBelongsToManyAssociation, :construct_find_options!)
@@ -89,7 +100,7 @@ module ActiveRecordShards
     end
 
     module HasAndBelongsToManyPreloaderPatches
-      def self.prepended(base)
+      def self.included(base)
         ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(false, base, :records_for) rescue nil
       end
 
@@ -97,8 +108,8 @@ module ActiveRecordShards
         klass.on_slave_unless_tx { yield }
       end
 
-      def exists?(*args, &block)
-        on_slave_unless_tx { super(*args, &block) }
+      def exists_with_default_slave?(*args, &block)
+        on_slave_unless_tx { exists_without_default_slave?(*args, &block) }
       end
     end
 
@@ -106,8 +117,15 @@ module ActiveRecordShards
     # this simplifies the hell out of our existence, because all we have to do is inerit on-slave-by-default
     # down from the parent now.
     module Rails41HasAndBelongsToManyBuilderExtension
-      def through_model
-        model = super
+      def self.included(base)
+        base.class_eval do
+          alias_method :through_model_without_inherit_default_slave_from_lhs, :through_model
+          alias_method :through_model, :through_model_with_inherit_default_slave_from_lhs
+        end
+      end
+
+      def through_model_with_inherit_default_slave_from_lhs
+        model = through_model_without_inherit_default_slave_from_lhs
         def model.on_slave_by_default?
           left_reflection.klass.on_slave_by_default?
         end

data/lib/active_record_shards/migration.rb

@@ -1,23 +1,19 @@
-module ActiveRecordShards
-  module Migrator
-    [:up, :down, :run].each do |m|
-      define_method(m) do |*args|
-        ActiveRecord::Base.on_shard(nil) do
-          super(*args)
-        end
-        ActiveRecord::Base.on_all_shards do
-          super(*args)
-        end
-      end
-    end
-  end
-end
-
-ActiveRecord::Migrator.singleton_class.send(:prepend, ActiveRecordShards::Migrator)
-
 module ActiveRecord
   class Migrator
     class << self
+      [:up, :down, :run].each do |m|
+        define_method("#{m}_with_sharding") do |*args|
+          ActiveRecord::Base.on_shard(nil) do
+            self.send("#{m}_without_sharding", *args)
+          end
+          ActiveRecord::Base.on_all_shards do
+            self.send("#{m}_without_sharding", *args)
+          end
+        end
+        alias_method :"#{m}_without_sharding", m.to_sym
+        alias_method m.to_sym, :"#{m}_with_sharding"
+      end
+
       def bootstrap_migrations_from_nil_shard(migrations_path, this_migration=nil)
         migrations = nil
         ActiveRecord::Base.on_shard(nil) do
@@ -88,7 +84,7 @@ module ActiveRecordShards
   # migration, where it should have been.  But this makes our monkey patch incompatible.
   # So we're forced to *either* include or extend this.
   module ActualMigrationExtension
-    def migrate(direction)
+    def migrate_with_forced_shard(direction)
       if migration_shard.blank?
         raise RuntimeError, "#{self.name}: Can't run migrations without a shard spec: this may be :all, :none,
                  or a specific shard (for data-fixups).  please call shard(arg) in your migration."
@@ -103,7 +99,7 @@ module ActiveRecordShards
         return if migration_shard != :all && migration_shard.to_s != shard.to_s
       end
 
-      super
+      migrate_without_forced_shard(direction)
     end
   end
 end
@@ -111,10 +107,12 @@ end
 ActiveRecord::Migration.class_eval do
   extend ActiveRecordShards::MigrationClassExtension
 
-  prepend ActiveRecordShards::ActualMigrationExtension
+  include ActiveRecordShards::ActualMigrationExtension
   define_method :migration_shard do
     self.class.migration_shard
   end
+  alias_method :migrate_without_forced_shard, :migrate
+  alias_method :migrate, :migrate_with_forced_shard
 end
 
 ActiveRecord::MigrationProxy.delegate :migration_shard, :to => :migration

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_shards
 version: !ruby/object:Gem::Version
-  version: 3.6.0
+  version: 3.6.1
 platform: ruby
 authors:
 - Mick Staugaard
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-23 00:00:00.000000000 Z
+date: 2016-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord