connection_manager 0.1.4 → 0.2.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    connection_manager (0.1.4)
+    connection_manager (0.2.0)
       activerecord (~> 3.0)
 
 GEM
@@ -39,7 +39,7 @@ GEM
     rspec-expectations (2.7.0)
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.7.0)
-    sqlite3 (1.3.4)
+    sqlite3 (1.3.5)
     tzinfo (0.3.31)
 
 PLATFORMS

data/README.md

@@ -119,7 +119,7 @@ available slave connections each time it is called using a different connection
     User.slave.where(['created_at BETWEEN ? and ?',Time.now - 5.days, Time.now]).all  => returns results from slave_2_user_data_development 
 
 ## TODO's
-* sharding
+* sharding - IN 2.0 AS BETA
 
 ## Other activerecord Connection gems
 * [Octopus](https://github.com/tchandy/octopus)

data/lib/connection_manager/associations.rb

@@ -26,4 +26,3 @@ module ConnectionManager
     end   
   end
 end
-ActiveRecord::Base.extend(ConnectionManager::Associations) 

data/lib/connection_manager/connections.rb

@@ -3,7 +3,7 @@ module ConnectionManager
     class << self
       @connection_keys
       @all
-      @replication_connections
+      @secondary_connections
       @env 
     
       def env
@@ -16,7 +16,7 @@ module ConnectionManager
       end
     
       # Get the current environment if defined
-      # Check for Rails, check for RACK_ENV, fail back to 'development'
+      # Check for Rails, check for RACK_ENV, default to 'development'
       def fetch_env
         return Rails.env if defined?(Rails)
         return RACK_ENV if defined?(RACK_ENV)
@@ -36,23 +36,23 @@ module ConnectionManager
       end
     
       # Holds connections
-      def replication_connections
-        @replication_connections ||= {}
+      def secondary_connections
+        @secondary_connections ||= {}
       end
     
       # Returns the database value given a connection key from the database.yml
       def database_name_from_yml(name_from_yml)
-        ActiveRecord::Base.configurations[name_from_yml]['database']
+        clean_db_name(ActiveRecord::Base.configurations[name_from_yml]['database'])
       end
-    
-      def clean_sqlite_db_name(name)
+      
+      def clean_sqlite_db_name(name,remove_env=true)
         new_name = "#{name}".gsub(/(\.sqlite3$)/,'')  
         new_name = new_name.split("/").last 
-        new_name.gsub!(Regexp.new("(\_#{env}$)"),'')
+        new_name.gsub!(Regexp.new("(\_#{env}$)"),'') if remove_env
         new_name
       end
       
-      def clean_bd_name(name)
+      def clean_db_name(name)
         new_name = "#{name}".gsub(Regexp.new("#{env}$"),'')
         if new_name.blank?
           new_name = "#{database_name_from_yml(name)}"
@@ -64,27 +64,27 @@ module ConnectionManager
       # Given an connection key name from the database.yml, returns the string 
       # equivelent of the class name for that entry.
       def connection_class_name(name_from_yml)
-        new_class_name = clean_bd_name(name_from_yml)  
+        new_class_name = clean_db_name(name_from_yml)  
         new_class_name = new_class_name.gsub(/\_/,' ').titleize.gsub(/ /,'')
         new_class_name << "Connection"
         new_class_name
       end 
      
-      def replication_key(name_from_yml)
-        rep_name = clean_bd_name(name_from_yml)
+      def secondary_key(name_from_yml)
+        rep_name = clean_db_name(name_from_yml)
         rep_name.gsub!(/(\_)+(\d+)/,'')
         rep_name.to_sym   
       end
     
-      def add_replication_connection(name_from_yml,new_connection)    
-        key = replication_key(name_from_yml)
-        replication_connections[key] ||= []
-        replication_connections[key] << new_connection
-        replication_connections
+      def add_secondary_connection(name_from_yml,new_connection)    
+        key = secondary_key(name_from_yml)
+        secondary_connections[key] ||= []
+        secondary_connections[key] << new_connection
+        secondary_connections
       end
     
-      def connections_for_replication(rep_collection_key)
-        replication_connections[(rep_collection_key.gsub(Regexp.new("(\_#{env}$)"),'')).to_sym]
+      def available_secondary_connections(rep_collection_key)
+        secondary_connections[(rep_collection_key.gsub(Regexp.new("(\_#{env}$)"),'')).to_sym]
       end
     
       # Sets class instance attributes, then builds connection classes, while populating
@@ -95,7 +95,7 @@ module ConnectionManager
         end     
         connection_keys.each do |connection|
           new_connection = connection_class_name(connection)  
-          add_replication_connection(connection,new_connection)
+          add_secondary_connection(connection,new_connection)
           build_connection_class(new_connection,connection) 
         end
         all
@@ -104,12 +104,13 @@ module ConnectionManager
       # Addes a conneciton subclass to Connections using the supplied
       # class name and connection key from database.yml
       def build_connection_class(class_name,connection_key)
-        class_eval <<-STR, __FILE__, __LINE__
-        class #{class_name} < ActiveRecord::Base
+        klass = Class.new(ActiveRecord::Base) do         
           self.abstract_class = true
-          establish_connection("#{connection_key}")
         end
-        STR
+        new_connection_class = Object.const_set(class_name, klass)
+        new_connection_class.establish_connection(connection_key)       
+
+        (const_set class_name, new_connection_class)
         all << class_name
       end
     end

data/lib/connection_manager/method_recorder.rb

@@ -0,0 +1,57 @@
+require 'active_record'
+module ConnectionManager 
+  class MethodRecorder  
+    attr_accessor :classes_to_call
+    
+    def initialize(classes_to_call=[])
+      self.classes_to_call = classes_to_call
+    end
+    
+    # A place to store our methods and thier variables
+    def recordings
+      @recordings ||= {}
+    end
+    
+    def execute_recordings
+      results = []
+      classes_to_call.each do |class_to_call|
+        called = nil
+        recordings.each do |name,args|
+          args = args[0] if [Array, Hash].include?args[0].class 
+          if called.nil?
+            if args.blank?
+              called = class_to_call.send(name.to_sym)         
+            else
+              called = class_to_call.send(name.to_sym, args)
+            end
+          else
+            if args.blank?
+              called = called.send(name.to_sym)
+            else
+              called = called.send(name.to_sym, args)
+            end
+          end
+        end
+        if called.is_a?(Array)
+          results = (results | called)
+        else
+          results << called
+        end   
+      end
+      results
+    end
+    
+    # Create recorder classes for methods that might be called on a ActiveRecord
+    # model in the process of building a query
+    (ActiveRecord::FinderMethods.instance_methods | ActiveRecord::QueryMethods.instance_methods).each do |method|
+      define_method(method) do |*args|
+        recordings[method] = args 
+        self
+      end
+    end
+    
+    def execute
+      execute_recordings
+    end
+  end  
+end

data/lib/connection_manager/{replication_builder.rb → secondary_connection_builder.rb}

@@ -1,11 +1,11 @@
 module ConnectionManager
-  module ReplicationBuilder
+  module SecondaryConnectionBuilder
     
     def database_name
       "#{connection.instance_variable_get(:@config)[:database].to_s}"
     end
     
-    def replication_association_options(method,association,class_name,options={})
+    def secondary_association_options(method,association,class_name,options={})
       new_options = {}.merge(options)
       if new_options[:class_name].blank?
         new_options[:class_name] = "#{association.to_s.singularize.classify}::#{class_name}"
@@ -19,14 +19,14 @@ module ConnectionManager
       new_options
     end
     
-    def build_replication_associations(class_name)
+    def build_secondary_associations(class_name)
       str = ""
       defined_associations.each do |method,defs|
         unless defs.blank?
           defs.each do |association,options|
             options = {} if options.blank?
             unless options[:no_readonly] || options[:class_name].to_s.match("::#{class_name}")
-              str << "#{method.to_s} :#{association}, #{replication_association_options(method,association,class_name,options)};" 
+              str << "#{method.to_s} :#{association}, #{secondary_association_options(method,association,class_name,options)};" 
             end
           end
         end
@@ -34,28 +34,36 @@ module ConnectionManager
       str
     end
     
-    def replication_connection_classes(options)
+    def secondary_connection_classes(options)
       if options[:using] && options[:using].is_a?(Array)
         connection_classes = options[:using].collect{|c| Connections.connection_class_name(c)}
       else  
         rep_name = "#{options[:name].to_s}_#{Connections.clean_sqlite_db_name(database_name)}"
-        connection_classes = Connections.connections_for_replication(rep_name) 
+        connection_classes = Connections.available_secondary_connections(rep_name) 
       end
       connection_classes
     end
-
     
+    def replicated(*settings)   
+      options = {:name => "slave", :readonly => true, :replication => true}.merge(settings.extract_options!)
+      build_secondary_connections(options)
+    end
+    
+    def sharded(*settings)   
+      options = {:name => "shard", :readonly => false, :shards => true}.merge(settings.extract_options!) 
+      build_secondary_connections(options)
+    end
+        
     # Adds subclass with the class name of the type provided in the options, which 
     # defaults to 'slave' if blank, that uses the connection from a connection class.
     # If :database option is blank?, replicated will assume the database.yml has
     # slave connections defined as: slave_database_name_test or slave_1_database_name_test, 
-    # where slave_1 is the replication instance, 'database_name' is the actual 
+    # where slave_1 is the secondary instance, 'database_name' is the actual 
     # name of the database and '_test' is the Rails environment
-    def replicated(*settings)   
-      options = {:name => "slave", :readonly => true}.merge(settings.extract_options!)   
-      connection_classes = replication_connection_classes(options)  
+    def build_secondary_connections(options={})     
+      connection_classes = secondary_connection_classes(options)  
       if connection_classes.blank?
-        raise ArgumentError, " a replication connection was not found. Check your database.yml."
+        raise ArgumentError, " a secondary connection was not found. Check your database.yml."
       else   
         connection_methods = []
         connection_classes.each do |c|
@@ -64,32 +72,34 @@ module ConnectionManager
           method_name = method_name.insert(method_name.index(/\d/),"_")
           class_name = method_name.classify
           connection_methods << method_name.to_sym
-          build_replication_class(class_name,c,options)
-          build_single_replication_method(method_name,class_name)
+          build_secondary_class(class_name,c,options)
+          build_single_secondary_method(method_name,class_name)
+          set_table_name_for_joins
         end
       end
-      build_full_replication_method(options,connection_methods)   
-  
+      
+      build_slaves_method(connection_methods)  if options[:replication]
+      build_shards_method(connection_methods)  if options[:shards]
     end
     
     # Creats a subclass that inherets from the model. The default model_name 
     # class method is overriden to return the super's name, which ensures rails
-    # helpers like link_to called on a replication stance generate a url for the
-    # master database. If options include readonly, build_replication_class also 
+    # helpers like link_to called on a secondary stance generate a url for the
+    # master database. If options include readonly, build_secondary_class also 
     # overrides the rails "readonly?" method to ensure saves are prevented. 
-    # Replication class can be called directly for operaitons.
+    # secondary class can be called directly for operaitons.
     # Usage: 
     #   User::Slave1.where(:id => 1).first => returns results from slave_1 database
-    #   User::Slave2.where(:id => 2).first => returns results from slave_1 database
-    def build_replication_class(class_name,connection_name,options)
+    #   User::Slave2.where(:id => 2).first => returns results from slave_2 database
+    #   User::Shard1.where(:id => 2).first => returns results from slave_1 database
+    def build_secondary_class(class_name,connection_name,options)
       class_eval <<-STR, __FILE__, __LINE__
       class #{class_name} < self
-        #{build_replication_associations(class_name)}
+        #{build_secondary_associations(class_name)}
         class << self
           def connection
             Connections::#{connection_name}.connection
           end
-
           def model_name
             ActiveModel::Name.new(#{name})
           end
@@ -99,11 +109,15 @@ module ConnectionManager
       STR
     end
     
-    # Adds as class method to call a specific replication conneciton.
+    def set_table_name_for_joins
+      self.table_name_prefix = "#{database_name}." unless database_name.match(/\.sqlite3$/)
+    end
+    
+    # Adds as class method to call a specific secondary conneciton.
     # Usage:
     #   User.slave_1.where(:id => 2).first => returns results from slave_1 database
     #   User.slave_2.where(:id => 2).first => returns results from slave_2 database
-    def build_single_replication_method(method_name,class_name)
+    def build_single_secondary_method(method_name,class_name)
       class_eval <<-STR, __FILE__, __LINE__
         class << self
           def #{method_name}
@@ -117,21 +131,36 @@ module ConnectionManager
     # on each call.
     # Usage:
     #   User.slave.where(:id => 2).first => can return results from slave_1 or slave_2 
-    def build_full_replication_method(options,connection_methods)
+    def build_slaves_method(connection_methods)
       class_eval <<-STR, __FILE__, __LINE__
       @connection_methods = #{connection_methods}
       class << self
-        def #{options[:name].to_s}
+        def slaves
           current = @connection_methods.shift
           @connection_methods << current
           send(current)
         end
+        alias :slave :slaves
         def connection_methods
           @connection_methods
         end
       end     
       STR
     end
+    
+    # add a class method that shifts through available connections methods
+    # on each call.
+    # Usage:
+    #   User.shards.where(:id => 2).first => can return results from slave_1 or slave_2 
+    def build_shards_method(connection_methods)
+      class_eval <<-STR, __FILE__, __LINE__
+      @shard_connection_methods = #{connection_methods}
+      class << self
+        def shards
+          ConnectionManager::MethodRecorder.new(@shard_connection_methods)
+        end
+      end     
+      STR
+    end
   end
-end
-ActiveRecord::Base.extend(ConnectionManager::ReplicationBuilder)
+end

data/lib/connection_manager/version.rb

@@ -1,4 +1,4 @@
 module ConnectionManager
-    VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end
 

data/lib/connection_manager.rb

@@ -4,7 +4,12 @@ module ConnectionManager
   require 'active_record'
   require 'connection_manager/connections'
   require 'connection_manager/associations'
-  require 'connection_manager/replication_builder'
-  require 'connection_manager/connection_manager_railtie.rb' if defined?(Rails)  
+  require 'connection_manager/secondary_connection_builder'
+  require 'connection_manager/method_recorder'
+  require 'connection_manager/connection_manager_railtie.rb' if defined?(Rails) 
+    
+  ActiveRecord::Base.extend(ConnectionManager::Associations) 
+  ActiveRecord::Base.extend(ConnectionManager::SecondaryConnectionBuilder)
+  
 end
 

data/spec/database.yml

@@ -17,4 +17,10 @@ slave_2_cm_test:
   adapter: sqlite3
   database: spec/cm_test.sqlite3
   pool: 5
-  timeout: 5000 
+  timeout: 5000
+  
+shard_1_cm_test:
+  adapter: sqlite3
+  database: spec/legacy_cm_test.sqlite3
+  pool: 5
+  timeout: 5000 

data/spec/integration/{replication_builder_spec.rb → secondary_connection_builder_spec.rb}

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 # Tests for associations build form replication.
 
-describe ConnectionManager::ReplicationBuilder do
+describe ConnectionManager::SecondaryConnectionBuilder do
   before(:all) do
     # Make sure connections recreated in other tests do not presist to current
     ConnectionManager::Connections.all.clear
-    ConnectionManager::Connections.replication_connections.clear
+    ConnectionManager::Connections.secondary_connections.clear
       
     #Initialize
     ConnectionManager::Connections.initialize(:env => 'test')
@@ -44,8 +44,7 @@ describe ConnectionManager::ReplicationBuilder do
   context "slave" do
     context('belongs_to') do
       it "should return the same belongs to object as master" do
-        fruit = Factory.create(:fruit)
-        
+        fruit = Factory.create(:fruit)      
         slave_fruit = Fruit.slave.where(:id => fruit.id).first
         slave_fruit.region.id.should eql(fruit.region.id)
       end

data/spec/lib/associations_spec.rb

@@ -1,15 +1,16 @@
 require 'spec_helper'
-
 class Foo < ActiveRecord::Base
   belongs_to :that
   has_many :foo_bars
   has_many :bars, :through => :foo_bars
   has_one :noob
 end
+
 class Bar < ActiveRecord::Base
   has_many :foo_bars
   has_many :foos, :through => :foo_bars
 end
+
 describe ConnectionManager::Associations do
   
   it "should add associations as keys to @defined_associations" do

data/spec/lib/connections_spec.rb

@@ -10,20 +10,20 @@ describe ConnectionManager::Connections do
     end
   end
   
-  context '#clean_bd_name' do
+  context '#clean_db_name' do
     context "when name is not just the Rails.env" do
       it "should remove the Rails.env from the string" do
-        ConnectionManager::Connections.clean_bd_name("my_database_test").should eql("my_database")
+        ConnectionManager::Connections.clean_db_name("my_database_test").should eql("my_database")
       end
     end
     context "when the name is only the Rails.env" do
       it "should use the name of the database and remove the Rails.env" do
         ConnectionManager::Connections.stubs(:database_name_from_yml).returns("my_database_test")
-        ConnectionManager::Connections.clean_bd_name("test").should eql("my_database")
+        ConnectionManager::Connections.clean_db_name("test").should eql("my_database")
       end
       it "should account for sqlite3 database name" do
         ConnectionManager::Connections.stubs(:database_name_from_yml).returns("db/my_database_test.sqlite3")
-        ConnectionManager::Connections.clean_bd_name("test").should eql("my_database")
+        ConnectionManager::Connections.clean_db_name("test").should eql("my_database")
       end
     end
   end
@@ -50,7 +50,7 @@ describe ConnectionManager::Connections do
     before(:all) do
       # Make sure connections recreated in other tests do not presist to tests tests
       ConnectionManager::Connections.all.clear
-      ConnectionManager::Connections.replication_connections.clear
+      ConnectionManager::Connections.secondary_connections.clear
       
       #Initialize
       ConnectionManager::Connections.initialize(:env => 'test')
@@ -58,18 +58,18 @@ describe ConnectionManager::Connections do
     
     context '#all' do
       it "should return the database.yml entries for the current rails environment" do
-        ConnectionManager::Connections.all.should eql(["CmConnection", 
-            "Slave1CmConnection", "Slave2CmConnection"])
+        ConnectionManager::Connections.all.should eql(["CmConnection",
+            "Slave1CmConnection", "Slave2CmConnection", "Shard1CmConnection"])
       end
     end
     
-    context '#replication_connections' do
+    context '#secondary_connections' do
       it "should return a hash where the keys are the generic undescored names for all connections" do
-        ConnectionManager::Connections.replication_connections.keys.
-          should eql([:cm, :slave_cm])
+        ConnectionManager::Connections.secondary_connections.keys.
+          should eql([:cm, :slave_cm, :shard_cm])
       end
       it "should return a hash where the values are an array of connection class names as strings" do
-        first_value = ConnectionManager::Connections.replication_connections.values.first
+        first_value = ConnectionManager::Connections.secondary_connections.values.first
         first_value.class.should eql(Array)
         defined?((ConnectionManager::Connections.class_eval(first_value[0]))).should be_true
       end
@@ -86,8 +86,7 @@ describe ConnectionManager::Connections do
       it "should have a super class of ActiveRecord::Base" do
         ConnectionManager::Connections::MyConnectionClass.superclass.should eql(ActiveRecord::Base)
       end
-    end
-    
+    end   
   end
 end
 

data/spec/lib/method_recorder_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe ConnectionManager::MethodRecorder do
+  before(:each) do
+    class Fruit < ActiveRecord::Base
+      #include ConnectionManager::MethodRecorder      
+      def self.shards
+        ConnectionManager::MethodRecorder.new([self])
+      end    
+    end
+  end
+  context 'shards'do    
+    it "it should record methods" do
+      a = Fruit.shards.select('fruits.*').where(:id => 1).order('created_at').first
+      a.recordings.should eql({:select => ['fruits.*'], :where => [:id =>1], :order => ['created_at'], :first => []})
+    end
+    
+    context '#execute' do
+      it "should return an array of results" do
+        a = Fruit.shards.first.execute
+        a.should be_a_kind_of(Array)
+      end
+      it "should execute the active record methods on the the provided class" do
+        fruit = Factory.create(:fruit)
+        class_to_call = Fruit
+        a = class_to_call.shards.where(:id => fruit.id).first.execute
+        a[0].should be_a_kind_of(class_to_call)
+      end
+   
+      it "should not matter how the where statement is formated" do
+        fruit = Factory.create(:fruit)
+        a = Fruit.shards.where(:id => fruit.id).first.execute
+        b = Fruit.shards.where(['id = ?', fruit.id]).first.execute
+        c = Fruit.shards.where('id = ?', fruit.id).first.execute    
+        (a == b && b == c).should be_true
+      end
+    end
+  end
+end

data/spec/lib/{replication_builder_spec.rb → secondary_connection_builder_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ConnectionManager::ReplicationBuilder do
+describe ConnectionManager::SecondaryConnectionBuilder do
   
   context '#database_name' do
     it "should return the name of the database the model is using" do
@@ -11,28 +11,28 @@ describe ConnectionManager::ReplicationBuilder do
   context '#other_association_options' do
     
       it "should add :class_name options set to the replication subclass if :class_name is blank" do
-        options = Fruit.replication_association_options(:has_one, :plant, 'Slave')
+        options = Fruit.secondary_association_options(:has_one, :plant, 'Slave')
         options[:class_name].should eql("Plant::Slave")
       end
       
       it "should append :class_name with the replication subclass if :class_name is not bank" do
-        options = Fruit.replication_association_options(:has_one, :plant, 'Slave', :class_name => 'Plant')
+        options = Fruit.secondary_association_options(:has_one, :plant, 'Slave', :class_name => 'Plant')
         options[:class_name].should eql("Plant::Slave")
       end
     
     context "has_one or has_many" do
     it "should add the :foreign_key if the :foreign_key options is not present" do
-      options = Fruit.replication_association_options(:has_one, :plant, 'Slave')
+      options = Fruit.secondary_association_options(:has_one, :plant, 'Slave')
       options[:foreign_key].should eql('fruit_id')
-      options = Fruit.replication_association_options(:has_many, :plant, 'Slave')
+      options = Fruit.secondary_association_options(:has_many, :plant, 'Slave')
       options[:foreign_key].should eql('fruit_id')
     end
     end
   end
   
-  context '#replication_connection_classes' do
+  context '#secondary_connection_classes' do
     it "should return the :using array with the array elements classified and append with Connection" do
-     Fruit.replication_connection_classes({:using => ['slave_1_test_db','slave_2_test_db']}).
+     Fruit.secondary_connection_classes({:using => ['slave_1_test_db','slave_2_test_db']}).
         should eql(["Slave1TestDbConnection", "Slave2TestDbConnection"])
     end
     
@@ -40,7 +40,7 @@ describe ConnectionManager::ReplicationBuilder do
   
   context '#replicated' do
     it "should raise an exception if no replication_connection_classes are found" do
-      Fruit.stubs(:replication_connection_classes).returns([])
+      Fruit.stubs(:secondary_connection_classes).returns([])
       lambda { Fruit.replicated }.should raise_error
     end
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: connection_manager
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-10 00:00:00.000000000Z
+date: 2011-12-27 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70145637967540 !ruby/object:Gem::Requirement
+  requirement: &70148774706040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70145637967540
+  version_requirements: *70148774706040
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70145637967120 !ruby/object:Gem::Requirement
+  requirement: &70148774705620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70145637967120
+  version_requirements: *70148774705620
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70145637966660 !ruby/object:Gem::Requirement
+  requirement: &70148774705160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70145637966660
+  version_requirements: *70148774705160
 - !ruby/object:Gem::Dependency
   name: autotest
-  requirement: &70145637966240 !ruby/object:Gem::Requirement
+  requirement: &70148774704740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70145637966240
+  version_requirements: *70148774704740
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70145637965820 !ruby/object:Gem::Requirement
+  requirement: &70148774704320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70145637965820
+  version_requirements: *70148774704320
 - !ruby/object:Gem::Dependency
   name: factory_girl
-  requirement: &70145637965400 !ruby/object:Gem::Requirement
+  requirement: &70148774703900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70145637965400
+  version_requirements: *70148774703900
 description: Simplifies connecting to Muliple and Replication databases with rails
   and active_record
 email:
@@ -97,16 +97,18 @@ files:
 - lib/connection_manager/associations.rb
 - lib/connection_manager/connection_manager_railtie.rb
 - lib/connection_manager/connections.rb
-- lib/connection_manager/replication_builder.rb
+- lib/connection_manager/method_recorder.rb
+- lib/connection_manager/secondary_connection_builder.rb
 - lib/connection_manager/version.rb
 - spec/database.yml
 - spec/factories.rb
 - spec/helpers/database_spec_helper.rb
 - spec/helpers/models_spec_helper.rb
-- spec/integration/replication_builder_spec.rb
+- spec/integration/secondary_connection_builder_spec.rb
 - spec/lib/associations_spec.rb
 - spec/lib/connections_spec.rb
-- spec/lib/replication_builder_spec.rb
+- spec/lib/method_recorder_spec.rb
+- spec/lib/secondary_connection_builder_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 homepage: ''
@@ -139,9 +141,10 @@ test_files:
 - spec/factories.rb
 - spec/helpers/database_spec_helper.rb
 - spec/helpers/models_spec_helper.rb
-- spec/integration/replication_builder_spec.rb
+- spec/integration/secondary_connection_builder_spec.rb
 - spec/lib/associations_spec.rb
 - spec/lib/connections_spec.rb
-- spec/lib/replication_builder_spec.rb
+- spec/lib/method_recorder_spec.rb
+- spec/lib/secondary_connection_builder_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb