connection_manager 1.1.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e1ece73057ea47a6c1602f2add01427a2ea71f84
-  data.tar.gz: 5315c54bb422f7d5a1108c2b24d5ed134441914b
+  metadata.gz: 147e706061b9694c3582c5d7afe29134b7b1fdbe
+  data.tar.gz: 93e2744959ed2c6fdb8b65fdd5c7a04c2535ee55
 SHA512:
-  metadata.gz: d8be9d03eee932357726baaae1acdf0219c819385d7e7b37ae034aa5135d6f0a365f579bc983de09f8faa6b72d9eb50a532fbbfb7212167bba575b6d83012939
-  data.tar.gz: 1ca913a938d454a87f5e2558306da6260f7c98cdca7e7aea9538bcbaeab5d98628ee6d35dfa00793846260672f6d0e2079ac561ab292c95df6e4e65cfe633507
+  metadata.gz: e5ca838d7a5b23faa9fdd3fac02484338b8f5a778e47427482827d4f2bddc8c2a30b09504ec8bd48ee66dc2b038592af025232751c40921c35f9d5fe464fa281
+  data.tar.gz: 9999b5b6365cf69d59ec15d34850453746493ceb8b926b3026b082c1a810a9371d6ee4c9e872b643ea2084a899d9acddff1a9776eae0ccca290adb563e41218d

data/.gitignore

@@ -5,3 +5,4 @@ pkg/*
 .DS_Store
 log/*
 Gemfile.lock
+.byebug_history

data/.travis.yml

@@ -0,0 +1,14 @@
+sudo: false
+cache: bundler
+language: ruby
+rvm:
+  - 2.3.1
+services:
+  - mysql
+  - postgresql
+
+script: bundle exec rspec spec
+gemfile:
+  - gemfiles/4.2.gemfile
+  - gemfiles/4.1.gemfile
+  - gemfiles/4.0.gemfile

data/README.md

@@ -1,4 +1,4 @@
-# ConnectionManager
+# ConnectionManager [![Build Status](https://travis-ci.org/JoshMcKin/connection_manager.svg)](https://travis-ci.org/JoshMcKin/connection_manager)
 Improved cross-schema, replication and mutli-DMS gem for ActiveRecord.
 
 ## Features
@@ -12,7 +12,7 @@ ConnectionManager is available through [Rubygems](https://rubygems.org/gems/conn
 
     $ gem install connection_manager
 
-## Rails 3/4 setup
+## Rails 4 setup
 
 Add connection_manager to you gemfile:
     
@@ -136,16 +136,15 @@ If there are multiple replication connections the system will pick a connection
     User.slaves.where('id BETWEEN ? and ?',1,100]).all  => returns results from slave_2_user_data_development 
 
 ### Repliation with cross-schema queries
-Setup replication as you would normally
+Setup replication as you would normally. Then build connection classes that inherit from you base connection 
+classes for each of your schemas.
 
-Next build connection classes that inherit from you base connection classes for each of your schemas
-EX
     class UserSchema < ActiveRecord::Base
       self.abstract_class = true
-      self.table_name_prefix = 'user_schema.'
+      self.schema_name = 'user_schema'
 
       def self.inherited(base)
-        base.use_schema(self.schema_name)
+        base.schema_name = self.schema_name
       end
     end
 
@@ -155,10 +154,10 @@ EX
 
     class FooSchema < ActiveRecord::Base
       self.abstract_class = true
-      self.table_name_prefix = 'foo.'
+      self.schema_name = 'foo'
 
       def self.inherited(base)
-        base.use_schema(self.schema_name)
+        base.schema_name = self.schema_name
       end
     end
 
@@ -168,7 +167,7 @@ EX
 
     User.joins(:bars).limit(1).to_sql # => SELECT * FROM `user_schema`.`users` INNER JOIN `foo.bars` ON `foo.bars`.`user_id` = `user_schema`.`users` LIMIT 1"
 
-## Sharding
+## Shards
 
 After tinkering with some solutions for shards, I've come to a similar conclusion as [DataFabric] (https://github.com/mperham/data_fabric):
 "Sharding should be implemented at the application level". The `shards` method is very basic and

data/connection_manager.gemspec

@@ -17,10 +17,11 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
-  s.add_runtime_dependency 'activerecord','>= 3.0', '< 5.0'
-  s.add_runtime_dependency 'activesupport','>= 3.0', '< 5.0'
-  s.add_runtime_dependency 'thread_safe'
-  s.add_development_dependency 'rspec', '~> 2.0'
+  s.add_runtime_dependency 'activerecord', '>= 3.0', '< 5.0'
+  s.add_runtime_dependency 'activesupport', '>= 3.0', '< 5.0'
+  s.add_runtime_dependency 'concurrent-ruby'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'rspec-autotest'
   s.add_development_dependency 'autotest'
   s.add_development_dependency 'mocha'
   s.add_development_dependency 'factory_girl'

data/gemfiles/4.0.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem 'activerecord','~> 4.0.0'
+gem 'mysql2', '~> 0.3.20'
+
+gemspec :path => "../"

data/gemfiles/4.1.gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem 'activerecord','~> 4.1.0'
+gem 'mysql2', '~> 0.3.20'
+
+
+gemspec :path => "../"

data/gemfiles/4.2.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem 'activerecord','~> 4.2.0'
+
+gemspec :path => "../"

data/lib/connection_manager.rb

@@ -1,20 +1,19 @@
 require "connection_manager/version"
+require 'concurrent'
+require 'active_record'
+require 'active_support'
+require 'connection_manager/connection_adapters/abstract_adapter'
+require 'connection_manager/core'
+require 'connection_manager/connection_handling'
+require 'connection_manager/relation'
+require 'connection_manager/querying'
+require 'connection_manager/builder'
+require 'connection_manager/using'
+require 'connection_manager/replication'
+require 'connection_manager/shards'
+require 'connection_manager/railtie' if defined?(Rails)
 
 module ConnectionManager
-  require 'thread_safe'
-  require 'active_record'
-  require 'active_support'
-  require 'connection_manager/connection_adapters/abstract_adapter'
-  require 'connection_manager/core'
-  require 'connection_manager/connection_handling'
-  require 'connection_manager/relation'
-  require 'connection_manager/querying'
-  require 'connection_manager/builder'
-  require 'connection_manager/using'
-  require 'connection_manager/replication'
-  require 'connection_manager/shards'
-  require 'connection_manager/railtie' if defined?(Rails)
-
   # Get the current environment if defined
   # Check for Rails, check for RACK_ENV, default to 'development'
   def self.env
@@ -32,7 +31,7 @@ module ConnectionManager
   def self.logger
     @logger ||= ActiveRecord::Base.logger
   end
-  
+
   def self.logger=logger
     @logger = logger
   end

data/lib/connection_manager/builder.rb

@@ -31,23 +31,27 @@ module ConnectionManager
 
       def env_regex
         return @env_regex if @env_regex
-        s = "#{ConnectionManager.env}$"
-        @env_regex = Regexp.new("(#{s})")
+        env_str = "#{ConnectionManager.env}$"
+        @env_regex = Regexp.new("(#{env_str})")
       end
 
       private
       # Creates a string to be used for the class name. Removes the current env.
       def clean_yml_key(name)
-        new_name = "#{name}".gsub(env_regex,'')
+        new_name = "#{name}"
+        new_name.gsub!(env_regex,'')
         new_name = "Base" if new_name.blank?
-        new_name.gsub(/\_$/,'')
+        new_name.gsub!(/\_$/,'')
+        new_name
       end
 
       # Given an connection key name from the database.yml, returns the string
       # equivalent of the class name for that entry.
       def connection_class_name(name_from_yml)
         new_class_name = clean_yml_key(name_from_yml)
-        new_class_name = new_class_name.gsub(/\_/,' ').titleize.gsub(/ /,'')
+        new_class_name.gsub!(/\_/,' ')
+        new_class_name.gsub!(/\b(?<!['’`])[a-z]/) { $&.capitalize! }
+        new_class_name.gsub!(/ /,'')
         new_class_name << "Connection"
         new_class_name
       end

data/lib/connection_manager/connection_adapters/abstract_adapter.rb

@@ -4,20 +4,20 @@ module ConnectionManager
 
     # Determines if connection supports cross database queries
     def cross_schema_support?
-      @cross_schema_support ||= (config[:adapter].match(/(mysql)|(postgres)|(sqlserver)/i))
+      @cross_schema_support ||= (config[:adapter] =~ /(mysql)|(postgres)|(sqlserver)/i)
     end
     alias :cross_database_support? :cross_schema_support?
 
     def mysql?
-      @is_mysql ||= (config[:adapter].match(/(mysql)/i))
+      @is_mysql ||= (config[:adapter] =~ /(mysql)/i)
     end
 
     def postgresql?
-      @is_postgresql ||= (config[:adapter].match(/(postgres)/i))
+      @is_postgresql ||= (config[:adapter] =~ /(postgres)/i)
     end
 
     def sqlserver?
-      @is_sqlserver ||= (config[:adapter].match(/(sqlserver)/i))
+      @is_sqlserver ||= (config[:adapter] =~ /(sqlserver)/i)
     end
 
     def replicated?

data/lib/connection_manager/connection_handling.rb

@@ -1,13 +1,12 @@
-require 'thread'
 require 'active_record/relation'
 module ConnectionManager
   module ConnectionHandling
-    @@managed_connections = ThreadSafe::Cache.new
+    @@managed_connections = Concurrent::Map.new
 
     # Attempts to return the schema from table_name and table_name_prefix
     def schema_name
-      return self.table_name.split('.')[0] if self.table_name && self.table_name.match(/\./)
-      return self.table_name_prefix.to_s.gsub(/\./,'') if self.table_name_prefix && self.table_name_prefix.match(/\./)
+      return self.table_name.split('.')[0] if self.table_name && self.table_name =~ /\./
+      return self.table_name_prefix.to_s.gsub(/\./,'') if self.table_name_prefix && self.table_name_prefix =~ /\./
       return self.connection.config[:database] if self.connection.mysql?
     end
     alias :database_name :schema_name
@@ -21,7 +20,7 @@ module ConnectionManager
     #     User.table_name_prefix  # => 'users_db.'
     #     User.table_name         # => 'users_db.users'
     def schema_name=schema_name
-      self.table_name_prefix = "#{schema_name}." if schema_name && schema_name.to_s != ""
+      self.table_name_prefix = "#{schema_name}." if schema_name && !schema_name.blank?
       self.table_name = "#{self.table_name_prefix}#{self.table_name}" unless self.abstract_class?
     end
     alias :database_name= :schema_name=
@@ -83,9 +82,5 @@ module ConnectionManager
     end
   end
 end
-if ActiveRecord::VERSION::MAJOR == 4
-  ActiveRecord::ConnectionHandling.send(:include, ConnectionManager::ConnectionHandling)
-else
-  require 'active_record/base'
-  ActiveRecord::Base.extend(ConnectionManager::ConnectionHandling)
-end
+ActiveRecord::ConnectionHandling.send(:include, ConnectionManager::ConnectionHandling)
+

data/lib/connection_manager/core.rb

@@ -17,8 +17,4 @@ module ConnectionManager
     end
   end
 end
-if ActiveRecord::VERSION::MAJOR == 4
-  ActiveRecord::Core::ClassMethods.send(:include,ConnectionManager::Core)
-else
-  ActiveRecord::Base.extend ConnectionManager::Core
-end
+ActiveRecord::Core::ClassMethods.send(:include,ConnectionManager::Core)

data/lib/connection_manager/querying.rb

@@ -1,13 +1,9 @@
 require 'active_support/core_ext/module/delegation'
 module ConnectionManager
   module Querying
-    delegate :using, :to => (ActiveRecord::VERSION::MAJOR == 4 ? :all : :scoped)
-    delegate :slaves, :to => (ActiveRecord::VERSION::MAJOR == 4 ? :all : :scoped)
-    delegate :masters, :to => (ActiveRecord::VERSION::MAJOR == 4 ? :all : :scoped)
+    delegate :using, :to =>  :all
+    delegate :slaves, :to =>  :all
+    delegate :masters, :to => :all
   end
 end
-if ActiveRecord::VERSION::MAJOR == 4
-  ActiveRecord::Querying.send(:include, ConnectionManager::Querying)
-else
-  ActiveRecord::Base.send(:extend, ConnectionManager::Querying)
-end
+ActiveRecord::Querying.send(:include, ConnectionManager::Querying)

data/lib/connection_manager/railtie.rb

@@ -1,7 +1,6 @@
 module ConnectionManager
   class Railtie < ::Rails::Railtie
     initializer "connection_manager.build_connection_classes" do
-      require 'connection_manager/connection_adapters/mysql_adapter' if (ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR <= 1 && (defined?(Mysql2::VERSION) || defined?(Mysql2::VERSION)))
       ConnectionManager.env = Rails.env
       ConnectionManager.logger = Rails.logger
       ConnectionManager::Builder.build_connection_classes(Rails.application.config.database_configuration.select{ |k,v| v['build_connection_class'] && k.match(ConnectionManager::Builder.env_regex)}.keys)

data/lib/connection_manager/replication.rb

@@ -1,20 +1,17 @@
 module ConnectionManager
   module Replication
-    attr_accessor :replication_connections
+
     # Replication methods (replication_method_name, which is the option[:name] for the
     # #replication method) and all their associated connections. The key is the
     # replication_method_name and the value is an array of all the replication_classes
     # the replication_method has access to.
     #
     # EX: replication_methods[:slaves] => ['Slave1Connection',Slave2Connection]
-    def replication_connections
-      @replication_connections ||= {:slaves => [], :masters => []}
-    end
-
+    attr_accessor :replication_connections
 
     # Is this class replicated
     def replicated?
-      (@replication_connections && (!replication_connections[:slaves].empty? || !replication_connections[:masters].empty?))
+      defined?(@replication_connections)
     end
 
     # Builds a class method that returns an ActiveRecord::Relation for use with
@@ -30,9 +27,13 @@ module ConnectionManager
     # * :name - name of class method to call to access replication, default to slaves
     # * :type - the type of replication; :slaves or :masters, defaults to :slaves
     def replicated(*connections)
-      options = {:slaves => [], :masters => [], :type => :slaves}.merge(connections.extract_options!.symbolize_keys)
-      options[options[:type]] = connections unless connections.empty?
-      set_replications_connections(options)
+      opts = connections.extract_options!
+      opts.symbolize_keys!
+      opts[:slaves] ||= []
+      opts[:masters] ||= []
+      opts[:type] ||= :slaves
+      opts[opts[:type]] = connections unless connections.empty?
+      set_replications_connections(opts)
     end
 
     def fetch_slave_connection
@@ -50,10 +51,11 @@ module ConnectionManager
     # connections we use sample to get a random connection instead of blocking
     # to rotate the pool on every fetch.
     def fetch_replication_connection(method_name)
-      set_replications_connections(self.replication_connections) unless self.replicated?
-      available_connections = self.replication_connections[method_name] || []
-      raise ArgumentError, "No connections found for #{method_name}." if available_connections.blank?
-      available_connections.sample
+      if @replication_connections && available_connections = @replication_connections[method_name]
+        available_connections.sample
+      else
+        raise ArgumentError, "Replication connections could not be found for #{method_name}."
+      end
     end
 
     # Builds replication connection classes and methods
@@ -61,21 +63,22 @@ module ConnectionManager
       [:masters,:slaves].each do |type|
         cons = (options[type].empty? ? connection.replications[type] : options[type])
         unless cons.empty?
-          self.replication_connections[type] = []
+          @replication_connections ||= {}
           cons.each do |to_use|
-            self.replication_connections[type] << fetch_connection_class_name(to_use)
+            @replication_connections[type] ||= []
+            @replication_connections[type] << fetch_connection_class_name(to_use)
           end
         end
       end
-      raise ArgumentError, "Connections could not be found for #{self.name}." if self.replication_connections[:masters].empty? && self.replication_connections[:slaves].empty?
-      self.replication_connections
+      raise ArgumentError, "Connection class could not be found for #{self.name}." unless (replicated? && (@replication_connections[:masters] || @replication_connections[:slaves]))
+      @replication_connections
     end
 
     def fetch_connection_class_name(to_use)
-      connection_class_name = to_use
-      connection_class_name = fetch_connection_class_name_from_yml_key(connection_class_name) if connection_class_name.to_s.match(/_/)
-      raise ArgumentError, "For #{self.name}, the class #{connection_class_name} could not be found." if connection_class_name.blank?
-      connection_class_name
+      conn_class_name = to_use
+      conn_class_name = fetch_connection_class_name_from_yml_key(conn_class_name) if conn_class_name.to_s =~ /_/
+      raise ArgumentError, "For #{self.name}, the class #{conn_class_name} could not be found." if conn_class_name.blank?
+      conn_class_name
     end
 
     def fetch_connection_class_name_from_yml_key(yml_key)

data/lib/connection_manager/shards.rb

@@ -1,16 +1,16 @@
 module ConnectionManager
-  module Shards  
+  module Shards
     @shard_class_names = []
-    
+
     def shard_class_names(*shard_class_names)
       @shard_class_names = shard_class_names
-    end 
-    
+    end
+
     # Takes a block that is call on all available shards.
     def shards(*opts,&shards_block)
       opts = {:include_self => true}.merge(opts.extract_options!)
       raise ArgumentError, "shard_class_names have not been defined for #{self.class.name}" if @shard_class_names.length == 0
-      if block_given?   
+      if block_given?
         results = []
         @shard_class_names.each do |s|
           results << shards_block.call(s.constantize)
@@ -23,4 +23,4 @@ module ConnectionManager
     end
   end
 end
-ActiveRecord::Base.extend(ConnectionManager::Shards)
+ActiveRecord::Base.extend(ConnectionManager::Shards)

data/lib/connection_manager/using.rb

@@ -1,3 +1,4 @@
+require 'active_record/querying.rb'
 module ConnectionManager
   module Using
     module ClassMethods
@@ -16,7 +17,10 @@ module ConnectionManager
         super(compare)
       end
     end
+
     class Proxy
+      include ActiveRecord::Querying
+
       attr_accessor :klass, :connection_class
 
       def initialize(klass,connection_class)
@@ -63,61 +67,6 @@ module ConnectionManager
         @klass.parent
       end
 
-      if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 0
-        # Rails 3.0
-        def find_by_sql(sql)
-          connection.select_all(sanitize_sql(sql), "#{name} Load").collect! { |record| instantiate(record) }
-        end
-        
-      elsif ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 1
-        # Rails 3.1
-        def find_by_sql(sql, binds = [])
-          connection.select_all(sanitize_sql(sql), "#{name} Load", binds).collect! { |record| instantiate(record) }
-        end
-
-      elsif ActiveRecord::VERSION::MAJOR == 3
-        # Rails 3.2
-        def find_by_sql(sql, binds = [])
-          logging_query_plan do
-            connection.select_all(sanitize_sql(sql), "#{name} Load", binds).collect! { |record| instantiate(record) }
-          end
-        end
-
-      elsif ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR <= 1
-        #Rails 4.0 & 4.1
-        def find_by_sql(sql, binds = [])
-          result_set = connection.select_all(sanitize_sql(sql), "#{name} Load", binds)
-          column_types = {}
-          if result_set.respond_to? :column_types
-            column_types = result_set.column_types
-          else
-            ActiveSupport::Deprecation.warn "the object returned from `select_all` must respond to `column_types`"
-          end
-          result_set.map { |record| instantiate(record, column_types) }
-        end
-
-      else
-        # Edge Rails
-        def find_by_sql(sql, binds = [])
-          result_set = connection.select_all(sanitize_sql(sql), "#{name} Load", binds)
-          column_types = result_set.column_types.dup
-          columns_hash.each_key { |k| column_types.delete k }
-          message_bus = ActiveSupport::Notifications.instrumenter
-          payload = {
-            record_count: result_set.length,
-            class_name: name
-          }
-          message_bus.instrument('instantiation.active_record', payload) do
-            result_set.map { |record| instantiate(record, column_types) }
-          end
-        end
-      end
-
-      def count_by_sql(sql)
-        sql = sanitize_conditions(sql)
-        connection.select_value(sql, "#{name} Count").to_i
-      end
-
       # Pass all methods to @klass, this ensures objects
       # build from the query are the correct class and
       # any settings in the model like table_name_prefix

data/lib/connection_manager/version.rb

@@ -1,3 +1,3 @@
 module ConnectionManager
-  VERSION = "1.1.5"
+  VERSION = "2.0.0"
 end

data/spec/helpers/database_spec_helper.rb

@@ -64,7 +64,6 @@ class TestMigrations < ActiveRecord::Migration
         create_table "cm_test.fruits" do |t|
           t.string :name
           t.integer :region_id
-          t.timestamps
         end
       rescue => e
         puts "tables failed to create: #{e}"
@@ -72,7 +71,6 @@ class TestMigrations < ActiveRecord::Migration
       begin
         create_table "cm_test.baskets" do |t|
           t.string :name
-          t.timestamps
         end
       rescue => e
         puts "tables failed to create: #{e}"
@@ -81,7 +79,6 @@ class TestMigrations < ActiveRecord::Migration
         create_table "cm_test.fruit_baskets" do |t|
           t.integer :fruit_id
           t.integer :basket_id
-          t.timestamps
         end
       rescue => e
         puts "tables failed to create: #{e}"
@@ -90,7 +87,6 @@ class TestMigrations < ActiveRecord::Migration
         create_table "cm_test.regions" do |t|
           t.string :name
           t.integer :type_id
-          t.timestamps
         end
       rescue => e
         puts "tables failed to create: #{e}"
@@ -98,7 +94,6 @@ class TestMigrations < ActiveRecord::Migration
       begin
         create_table "cm_test.types" do |t|
           t.string :name
-          t.timestamps
         end
       rescue => e
         puts "tables failed to create: #{e}"
@@ -117,7 +112,6 @@ class TestMigrations < ActiveRecord::Migration
     begin
       create_table "cm_user_test.types" do |t|
         t.string :name
-        t.timestamps
       end
     rescue => e
       puts "tables failed to create: #{e}"

data/spec/lib/builder_spec.rb

@@ -18,14 +18,14 @@ describe ConnectionManager::Builder do
       ConnectionManager::Builder.build_connection_class("MyConnectionClass", :test)
     end
     it "should add a class with supplied class name to ConnectionManager::Builder" do
-      expect(defined?(MyConnectionClass)).to be_true
+      expect(defined?(MyConnectionClass)).to eql("constant")
       expect(MyConnectionClass).to be_a(Class)
     end
     it "should have a super class of ActiveRecord::Base" do
      expect(MyConnectionClass.superclass).to eql(ActiveRecord::Base)
     end
     it "should be an abstract class" do
-      expect(MyConnectionClass.abstract_class?).to be_true
+      expect(MyConnectionClass.abstract_class?).to eql(true)
     end
   end   
 end

data/spec/lib/connection_adapters/abstract_adapter_spec.rb

@@ -11,15 +11,15 @@ describe ConnectionManager::AbstractAdapter do
   describe '#cross_schema_support?' do
     it "should be true for Mysql" do
       @con.stubs(:config).returns({:adapter => 'mysql'})
-      expect(@con.cross_schema_support?).to be_true
+      expect(@con).to be_cross_schema_support
     end
     it "should be true for Postgres" do
       @con.stubs(:config).returns({:adapter => 'postgresql'})
-      expect(@con.cross_schema_support?).to be_true
+      expect(@con).to be_cross_schema_support
     end
     it "should be true for SQL server" do
       @con.stubs(:config).returns({:adapter => 'sqlserver'})
-      expect(@con.cross_schema_support?).to be_true
+      expect(@con).to be_cross_schema_support
     end
   end
 

data/spec/lib/connection_adapters/mysql_adapter_spec.rb

@@ -4,10 +4,10 @@ require 'spec_helper'
 describe  ActiveRecord::Base do
   describe '#table_exists?' do
     it "should return true for unquoted full_names" do
-      expect(Fruit.connection.table_exists?('cm_test.fruits')).to be_true
+      expect(Fruit.connection.table_exists?('cm_test.fruits')).to eql(true)
     end
     it "should return true for table only names" do
-      expect(Fruit.connection.table_exists?('fruits')).to be_true
+      expect(Fruit.connection.table_exists?('fruits')).to eql(true)
     end
   end
 end

data/spec/lib/connection_handling_spec.rb

@@ -47,18 +47,18 @@ describe ConnectionManager::ConnectionHandling do
 
   describe '#establish_connection' do
     it "should register class as connection class" do
-      expect(ActiveRecord::Base.managed_connection_classes.include?("MyConnectionClass")).to be_true
+      expect(ActiveRecord::Base.managed_connection_classes.include?("MyConnectionClass")).to eql(true)
     end
   end
 
   describe '#establish_managed_connection' do
     context 'the connection class' do
       it "should create abstract class" do
-        expect(MyManagedConnectionClass.abstract_class).to be_true
+        expect(MyManagedConnectionClass.abstract_class).to eql(true)
       end
 
       it "should check in the connection" do
-        expect(ActiveRecord::Base.managed_connection_classes.include?("MyManagedConnectionClass")).to be_true
+        expect(ActiveRecord::Base.managed_connection_classes.include?("MyManagedConnectionClass")).to eql(true)
       end
     end
   end

data/spec/lib/integration/cross_schema_spec.rb

@@ -9,14 +9,14 @@ describe ActiveRecord::Base do
 
   describe '#joins' do
     it "should work" do
-      @user.foos.blank?.should be_false
+      @user.foos.blank?.should eql(false)
       found = Foo.joins(:cm_user).select('cm_users.name AS user_name').where('cm_users.id = ?',@user.id).first
       expect(found.user_name).to_not be_blank
     end
   end
   describe '#includes' do
     before(:each) do
-      @user.foos.blank?.should be_false
+      @user.foos.blank?.should eql(false)
       search = Foo.includes(:cm_user).where('cm_users.id = ?',@user.id)
       search = search.references(:cm_user) if search.respond_to?(:references)
       @found = search.first

data/spec/lib/replication_spec.rb

@@ -12,7 +12,7 @@ describe ConnectionManager::Replication do
       ActiveRecord::Base.stubs(:replication_connections).returns({:masters => [], :slaves => []})
       ActiveRecord::ConnectionAdapters::AbstractAdapter.any_instance.stubs(:slave_keys).returns([])
       ActiveRecord::ConnectionAdapters::AbstractAdapter.any_instance.stubs(:master_keys).returns([])
-      expect(lambda { Fruit.replicated }).to raise_error
+      expect(lambda { Fruit.replicated }).to raise_error(ArgumentError)
     end
 
     it "should not raise an exception if no connections are empty, but connection.replication_keys are not blank" do

data/spec/lib/shards_spec.rb

@@ -17,7 +17,7 @@ describe ConnectionManager::Shards do
       a = Fruit.shards do |shard|
         shard.where(:id => fruit.id).first
       end
-      expect(klasses.include?(a[0].class.name)).to be_true
+      expect(klasses.include?(a[0].class.name)).to eql(true)
     end
    
       
@@ -34,7 +34,7 @@ describe ConnectionManager::Shards do
       cfruit = Fruit.shards do |shard|
         shard.where('id = ?', fruit.id).first    
       end
-      expect((afruit == bfruit && bfruit == cfruit)).to be_true
+      expect((afruit == bfruit && bfruit == cfruit)).to eql(true)
     end
   end
 end

data/spec/lib/using_spec.rb

@@ -43,7 +43,7 @@ describe ConnectionManager::Using do
     context 'A shard like connection' do
       it "should use other connection" do
         fruit = FactoryGirl.create(:fruit)
-        expect(Fruit.using("OtherConnection").where(:name => fruit.name).exists?).to be_false
+        expect(Fruit.using("OtherConnection").where(:name => fruit.name).exists?).to eql(false)
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: connection_manager
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 2.0.0
 platform: ruby
 authors:
 - Joshua Mckinney
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-05 00:00:00.000000000 Z
+date: 2016-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -51,7 +51,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: thread_safe
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -70,14 +70,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-autotest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: autotest
   requirement: !ruby/object:Gem::Requirement
@@ -158,16 +172,19 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
 - CHANGE.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - connection_manager.gemspec
+- gemfiles/4.0.gemfile
+- gemfiles/4.1.gemfile
+- gemfiles/4.2.gemfile
 - lib/connection_manager.rb
 - lib/connection_manager/builder.rb
 - lib/connection_manager/connection_adapters/abstract_adapter.rb
-- lib/connection_manager/connection_adapters/mysql_adapter.rb
 - lib/connection_manager/connection_handling.rb
 - lib/connection_manager/core.rb
 - lib/connection_manager/querying.rb

data/lib/connection_manager/connection_adapters/mysql_adapter.rb

@@ -1,39 +0,0 @@
-module ConnectionManager
-  module MysqlAdapter
-
-    # Force all tables to be cached for the life connection
-    def cached_tables
-      @cached_tables ||= {}
-    end
-
-    def new_tables(name = nil, database = nil, like =nil)
-      return cached_tables[database] if cached_tables[database] && like.nil?
-      cached_tables[database] ||= []
-      return [like] if like && cached_tables[database].include?(like)
-      sql = "SHOW TABLES "
-      sql << "IN #{database} " if database
-      sql << "LIKE #{quote(like)}" if like
-      result = execute(sql, 'SCHEMA')
-      cached_tables[database] = (cached_tables[database] | result.collect { |field| field[0] }).compact
-    end
-    alias :tables :new_tables
-
-
-    # We have to clean the name of '`' and fetch table name with schema
-    def table_exists?(name)
-      return false unless name
-      name          = name.to_s
-      schema, table = name.split('.', 2)
-      unless table # A table was provided without a schema
-        table  = schema
-        schema = nil
-      end
-      new_tables(nil, schema, table).include?(table)
-    end
-  end
-end
-if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR <= 1
-  require 'active_record/connection_adapters/mysql2_adapter'
-  ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:include,(ConnectionManager::MysqlAdapter)) if defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter)
-  ActiveRecord::ConnectionAdapters::Mysql2Adapter.send(:include,(ConnectionManager::MysqlAdapter))
-end