switchman 1.5.9 → 1.5.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: abf642d4e18ec28d2f9b71eb4aa3d4edb8ec8a92
-  data.tar.gz: 64297343a489ffdfc3eb22f851a2c11dc797d211
+  metadata.gz: a864ee73e89a300af961ba7041f8f82ae193d9e5
+  data.tar.gz: 3b15e10e5bcb9dccd99e3b88b257f1f95c551a9b
 SHA512:
-  metadata.gz: b3c185968b0864ed798bda19dedb9268473f672e118ce01636f3d9c0449f902b7c3ae6a2244342530566232e42b38739df47f5af93ed00d3be60eb1c20906c7e
-  data.tar.gz: 3abd5123fa4d0807492131fd0179d17df0784b6c6abbca69fc178db9cd4fb78338037414ee0f3a44294d832933471010524e93c7a580361869eedeba535ff609
+  metadata.gz: aa6ea9736d0316467d7f9493eecb127ed352a2421df4789b8ceb129f5a6eb9ed893ae3863dc72b15268bf7241c55d97dea00b26f78e9dafc0059e18999575a78
+  data.tar.gz: 0ee49239c7054e8e510c350aa0c9fe529c92e18fd50ee8ee8ceb468e9d2971f99ce788ce4071543d2b2f85bb73dcad94ef1f36b171cc6f09ad420ba8ec50e03e

data/lib/switchman/active_record/query_methods.rb

@@ -110,7 +110,7 @@ module Switchman
       private
 
       [:where, :having].each do |type|
-        class_eval <<-RUBY
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def transpose_#{type}_clauses(source_shard, target_shard, remove_nonlocal_primary_keys)
             if ::Rails.version >= '5'
               unless (predicates = #{type}_clause.send(:predicates)).empty?
@@ -263,7 +263,11 @@ module Switchman
           relation, column = relation_and_column(predicate.left)
           next predicate unless (type = transposable_attribute_type(relation, column))
 
-          remove = true if type == :primary && remove_nonlocal_primary_keys && predicate.left.relation.model == klass
+          remove = true if type == :primary &&
+              remove_nonlocal_primary_keys &&
+              predicate.left.relation.model == klass &&
+              predicate.is_a?(::Arel::Nodes::Equality)
+
           current_source_shard =
               if source_shard
                 source_shard
@@ -321,7 +325,7 @@ module Switchman
             predicate.right
           else
             local_id = Shard.relative_id_for(predicate.right, current_source_shard, target_shard)
-            local_id = [] if remove && local_id > Shard::IDS_PER_SHARD
+            local_id = [] if remove && local_id.is_a?(Fixnum) && local_id > Shard::IDS_PER_SHARD
             local_id
           end
 

data/lib/switchman/active_record/relation.rb

@@ -38,6 +38,10 @@ module Switchman
         primary_shard.activate(klass.shard_category) { super }
       end
 
+      def to_sql
+        primary_shard.activate(klass.shard_category) { super }
+      end
+
       def explain(super_method: false)
         return super() if super_method
         self.activate { |relation| relation.explain(super_method: true) }

data/lib/switchman/engine.rb~

@@ -0,0 +1,203 @@
+module Switchman
+  class Engine < ::Rails::Engine
+    require 'byebug'
+    debugger
+    isolate_namespace Switchman
+
+    config.autoload_once_paths << File.expand_path(File.join(__FILE__, "../../../app/models"))
+
+    def self.lookup_stores(cache_store_config)
+      result = {}
+      cache_store_config.each do |key, value|
+        next if value.is_a?(String)
+        result[key] = ::ActiveSupport::Cache.lookup_store(value)
+      end
+
+      cache_store_config.each do |key, value|
+        next unless value.is_a?(String)
+        result[key] = result[value]
+      end
+      result
+    end
+
+    initializer 'switchman.initialize_cache', :before => 'initialize_cache' do
+      require "switchman/active_support/cache"
+      ::ActiveSupport::Cache.singleton_class.prepend(ActiveSupport::Cache::ClassMethods)
+
+      # if we haven't already setup our cache map out-of-band, set it up from
+      # config.cache_store now. behaves similarly to Rails' default
+      # initialize_cache initializer, but for each value in the map, rather
+      # than just Rails.cache. if config.cache_store is a flat value, uses it
+      # to fill just the Rails.env entry in the cache map.
+      unless Switchman.config[:cache_map].present?
+        cache_store_config = ::Rails.configuration.cache_store
+        unless cache_store_config.is_a?(Hash)
+          cache_store_config = {::Rails.env => cache_store_config}
+        end
+
+        Switchman.config[:cache_map] = Engine.lookup_stores(cache_store_config)
+      end
+
+      # if the configured cache map (either from before, or as populated from
+      # config.cache_store) didn't have an entry for Rails.env, add one using
+      # lookup_store(nil); matches the behavior of Rails' default
+      # initialize_cache initializer when config.cache_store is nil.
+      unless Switchman.config[:cache_map].has_key?(::Rails.env)
+        value = ::ActiveSupport::Cache.lookup_store(nil)
+        Switchman.config[:cache_map][::Rails.env] = value
+      end
+
+      middlewares = Switchman.config[:cache_map].values.map do |store|
+        store.middleware if store.respond_to?(:middleware)
+      end.compact.uniq
+      middlewares.each do |middleware|
+        config.middleware.insert_before("Rack::Runtime", middleware)
+      end
+
+      # prevent :initialize_cache from trying to (or needing to) set
+      # Rails.cache. once our switchman.extend_ar initializer (below) runs
+      # Rails.cache will be overridden to pull appropriate values from the
+      # cache map, but between now and then, Rails.cache should return the
+      # Rails.env entry in the cache map.
+      ::Rails.cache = Switchman.config[:cache_map][::Rails.env]
+
+      require "switchman/rails"
+      ::Rails.singleton_class.prepend(Rails::ClassMethods)
+    end
+
+    initializer 'switchman.asplode', :after => "active_record.initialize_database" do
+      ::Rails.cache
+    end
+
+      initializer 'switchman.extend_ar', :before => "active_record.initialize_database" do
+      ::ActiveSupport.on_load(:active_record) do
+        require 'byebug'
+        debugger
+        require "switchman/active_record/abstract_adapter"
+        require "switchman/active_record/association"
+        require "switchman/active_record/attribute_methods"
+        require "switchman/active_record/base"
+        require "switchman/active_record/calculations"
+        require "switchman/active_record/connection_handler"
+        require "switchman/active_record/connection_pool"
+        require "switchman/active_record/finder_methods"
+        require "switchman/active_record/log_subscriber"
+        require "switchman/active_record/model_schema"
+        require "switchman/active_record/persistence"
+        require "switchman/active_record/predicate_builder"
+        require "switchman/active_record/query_cache"
+        require "switchman/active_record/query_methods"
+        require "switchman/active_record/reflection"
+        require "switchman/active_record/relation"
+        require "switchman/active_record/spawn_methods"
+        require "switchman/active_record/where_clause_factory"
+        require "switchman/active_record/type_caster"
+        require "switchman/arel"
+        require "switchman/shackles/relation"
+
+        include ActiveRecord::Base
+        include ActiveRecord::AttributeMethods
+        include ActiveRecord::Persistence
+        singleton_class.prepend ActiveRecord::ModelSchema::ClassMethods
+
+        if ::Rails.version > '4.2'
+          require "switchman/active_record/statement_cache"
+          ::ActiveRecord::StatementCache.prepend(ActiveRecord::StatementCache)
+          ::ActiveRecord::StatementCache::BindMap.prepend(ActiveRecord::StatementCache::BindMap)
+          ::ActiveRecord::StatementCache::Substitute.send(:attr_accessor, :primary, :sharded)
+
+          ::ActiveRecord::Associations::CollectionAssociation.prepend(ActiveRecord::CollectionAssociation)
+          ::ActiveRecord::PredicateBuilder.singleton_class.prepend(ActiveRecord::PredicateBuilder)
+        end
+
+        if ::Rails.version > '4.1'
+          prepend(ActiveRecord::AutosaveAssociation)
+        end
+
+        ::ActiveRecord::Associations::Association.prepend(ActiveRecord::Association)
+        ::ActiveRecord::Associations::BelongsToAssociation.prepend(ActiveRecord::BelongsToAssociation)
+        ::ActiveRecord::Associations::CollectionProxy.include(ActiveRecord::CollectionProxy)
+        if ::Rails.version < '5'
+          ::ActiveRecord::Associations::Builder::CollectionAssociation.include(ActiveRecord::Builder::CollectionAssociation)
+        end
+
+        ::ActiveRecord::Associations::Preloader::Association.prepend(ActiveRecord::Preloader::Association)
+        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::AbstractAdapter)
+        ::ActiveRecord::ConnectionAdapters::ConnectionHandler.prepend(ActiveRecord::ConnectionHandler)
+        ::ActiveRecord::ConnectionAdapters::ConnectionPool.prepend(ActiveRecord::ConnectionPool)
+        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::QueryCache)
+        # when we call super in Switchman::ActiveRecord::QueryCache#select_all,
+        # we want it to find the definition from
+        # ActiveRecord::ConnectionAdapters::DatabaseStatements, not
+        # ActiveRecord::ConnectionAdapters::QueryCache
+        ::ActiveRecord::ConnectionAdapters::QueryCache.send(:remove_method, :select_all)
+
+        ::ActiveRecord::LogSubscriber.prepend(ActiveRecord::LogSubscriber)
+        ::ActiveRecord::Reflection::AssociationReflection.prepend(ActiveRecord::Reflection::AssociationReflection)
+        ::ActiveRecord::Relation.prepend(ActiveRecord::Calculations)
+        ::ActiveRecord::Relation.include(ActiveRecord::FinderMethods)
+        ::ActiveRecord::Relation.include(ActiveRecord::QueryMethods)
+        ::ActiveRecord::Relation.prepend(ActiveRecord::Relation)
+        ::ActiveRecord::Relation.include(ActiveRecord::SpawnMethods)
+        ::ActiveRecord::Relation.prepend(Shackles::Relation)
+
+        if ::Rails.version >= '5'
+          ::ActiveRecord::Relation::WhereClauseFactory.prepend(ActiveRecord::WhereClauseFactory)
+          ::ActiveRecord::PredicateBuilder::AssociationQueryValue.prepend(ActiveRecord::PredicateBuilder::AssociationQueryValue)
+          ::ActiveRecord::TypeCaster::Map.include(ActiveRecord::TypeCaster::Map)
+          ::ActiveRecord::TypeCaster::Connection.include(ActiveRecord::TypeCaster::Connection)
+        end
+
+        ::Arel::Table.prepend(Arel::Table)
+        ::Arel::Visitors::ToSql.prepend(Arel::Visitors::ToSql)
+        ::Arel::Visitors::PostgreSQL.include(Arel::Visitors::PostgreSQL) if ::Rails.version < '4.2'
+      end
+    end
+
+    def self.foreign_key_check(name, type, options)
+      if name.to_s =~ /_id\z/ && type.to_s == 'integer' && options[:limit].to_i < 8
+        puts "WARNING: All foreign keys need to be 8-byte integers. #{name} looks like a foreign key. If so, please add the option: `:limit => 8`"
+      end
+    end
+
+    initializer 'switchman.extend_connection_adapters', :after => "active_record.initialize_database" do
+      ::ActiveSupport.on_load(:active_record) do
+        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.descendants.each do |klass|
+          klass.prepend(ActiveRecord::AbstractAdapter::ForeignKeyCheck)
+        end
+
+        require 'switchman/active_record/table_definition'
+        ::ActiveRecord::ConnectionAdapters::TableDefinition.prepend(ActiveRecord::TableDefinition)
+
+        if defined?(::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+          require "switchman/active_record/postgresql_adapter"
+          ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(ActiveRecord::PostgreSQLAdapter)
+        end
+      end
+    end
+
+    initializer 'switchman.eager_load' do
+      ::ActiveSupport.on_load(:before_eager_load) do
+        # This needs to be loaded before Switchman::Shard, otherwise it won't autoload it correctly
+        require 'active_record/base'
+      end
+    end
+
+    initializer 'switchman.extend_shackles', :before => "switchman.extend_ar" do
+      ::ActiveSupport.on_load(:active_record) do
+        require "switchman/shackles"
+
+        ::Shackles.singleton_class.prepend(Shackles::ClassMethods)
+      end
+    end
+
+    initializer 'switchman.extend_controller', :after => "shackles.extend_ar" do
+      ::ActiveSupport.on_load(:action_controller) do
+        require "switchman/action_controller/caching"
+
+        ::ActionController::Base.include(ActionController::Caching)
+      end
+    end
+
+  end
+end

data/lib/switchman/version.rb

@@ -1,3 +1,3 @@
 module Switchman
-  VERSION = "1.5.9"
+  VERSION = "1.5.10"
 end

data/lib/tasks/switchman.rake

@@ -49,7 +49,7 @@ module Switchman
       old_actions = old_task.actions.dup
       old_task.actions.clear
 
-      old_task.enhance do
+      old_task.enhance do |*task_args|
         if ::Rails.env.test?
           require 'switchman/test_helper'
           TestHelper.recreate_persistent_test_shards(dont_create: true)
@@ -62,7 +62,7 @@ module Switchman
             ::ActiveRecord::Base.connection_pool.spec.config[:shard_name] = Shard.current.name
             ::ActiveRecord::Base.configurations[::Rails.env] = ::ActiveRecord::Base.connection_pool.spec.config.stringify_keys
             shard.database_server.unshackle do
-              old_actions.each(&:call)
+              old_actions.each { |action| action.call(*task_args) }
             end
             nil
           end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: switchman
 version: !ruby/object:Gem::Version
-  version: 1.5.9
+  version: 1.5.10
 platform: ruby
 authors:
 - Cody Cutrer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-10 00:00:00.000000000 Z
+date: 2016-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -162,7 +162,6 @@ files:
 - app/models/switchman/shard_internal.rb
 - db/migrate/20130328212039_create_switchman_shards.rb
 - db/migrate/20130328224244_create_default_shard.rb
-- db/shard_1708.sqlite3
 - lib/switchman.rb
 - lib/switchman/action_controller/caching.rb
 - lib/switchman/active_record/abstract_adapter.rb
@@ -194,6 +193,7 @@ files:
 - lib/switchman/database_server.rb
 - lib/switchman/default_shard.rb
 - lib/switchman/engine.rb
+- lib/switchman/engine.rb~
 - lib/switchman/environment.rb
 - lib/switchman/errors.rb
 - lib/switchman/r_spec_helper.rb
@@ -225,7 +225,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Rails 4 sharding magic