connection_manager 1.0.3 → 1.0.4

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MzFmOGFhMDMwNmVlMWJmZTkxNGUyOWY0NzMyZjQ0ZGI0MDZlOGE4MA==
+    MTEwZjBmOTI5ZTVjMTI0OGJkZDQwODg0NzcwYTIzZGUxYTI5M2M4NQ==
   data.tar.gz: !binary |-
-    ZWE0OTc3YjJhZTgwMWU2ZTAyYzlkNzBhZDM1MjZjYzU2OTNkNjU0NA==
+    ZGJjMWY5YWU4Zjc0OTI3MWMxMTczYTAwMTNmYzI0MTY2OGJhYTEyNQ==
 SHA512:
   metadata.gz: !binary |-
-    NDkzOTE4YzIyZTc2MWM5MjMyNzQ1ZTc3ZjUxYjlkYmYwYWE5N2UyMjYzODcw
-    MDFlZGNiMTRjOGRkMjViYTUwNjE4ZWRlYTFhYzkwOTQyYjJmOWU3ZDc1NzVj
-    OTg3OGQ4NDFiOTQzMjZmZjU0OGQxYWE0OWUzNzY1OThkYWY5ZjY=
+    NjIxODExY2IwYzEzY2Y4MjU3ODAyMGVhZTZmYTM0YTcwODAzMDYxMWYyNjU5
+    NWE3N2M2YzBkYTYxYzk3ZDdiYzA5NzgzYjQ0ODU5Y2E5MmMwMDM5OWU5MTA4
+    MGUzMGNiNjE3NDdiNGYwYzUwYjZlM2NhNWM3ZDAyOWE2ZWQxYzE=
   data.tar.gz: !binary |-
-    ZDkxN2VlYWIxODBkZGNlNjdkMWMyY2Q4NDRhN2NhMWVkZGIyOTgyM2QwNjEx
-    NmRhMDY1YWMxNjRkOGEyYjE2MDQwZTQ2Yjg2Y2Y5ZmVmZjk4Y2MzMWQxODBl
-    MTdkOWJlNTA0YzE3MmVlN2YzMGM1YzcwMjM3MmZiNTRiZTZiZjQ=
+    NGFiOWQ5NTQyZGYyZmNkYzQ0NWI0ZjVmYjg3NDhmZTE1YjY5MzVlY2Y0NmFh
+    OTY1ZTczNjE5ZWFlZDU4YmQ5OWIxZmUxNmMyYzI2MTg3N2QzNmMwOWIzMmY0
+    NTI1ZGUzNWFiNWJhZDc3ZjQ0NGFjZjEwYTNkYzU1MjhjOWUzZjE=

data/CHANGE.md

@@ -5,6 +5,10 @@ HEAD
 =======
 - None yet!
 
+1.0.4
+=======
+- Stop duping classes for using, use proxy that returns instance of Class query is called on.
+
 1.0.3
 =======
 - Fix issue where ActiveRecord::ConnectionNotEstablished error is raised in Rails app with Engine that requires delayed/backend/active_record

data/README.md

@@ -11,20 +11,13 @@ for multiple database support in Rails with a few class methods and simple
 database.yml configuration. Since ConnectionManager does not alter
 ActiveRecord's connection pool, thread safety is not a concern.
 
-## Upgrading to 0.3
-
-0.3 is a complete overhaul and will cause compatibility issues for folks who upgrade using the previous replication setup.
-Fortunately, for most folks the only change they have to do is specify the their slaves
-and masters in the database.yml and set build_connection_class to true to have
-ActiveRecord build their connection classes. See the example database.yml below.
-
 ## Installation
 
 ConnectionManager is available through [Rubygems](https://rubygems.org/gems/connection_manager) and can be installed via:
 
     $ gem install connection_manager
 
-## Rails 3/4 setup (No Rails 2 at this time)
+## Rails 3/4 setup
 
 Add connection_manager to you gemfile:
     
@@ -176,7 +169,7 @@ to your shard requirements.
 
 ## Caching
 
-ActiveRecord only caches queries for the ActiveRecord::Base connection. Inorder to cache queries that
+ActiveRecord only caches queries for the ActiveRecord::Base connection. In order to cache queries that
 originate from classes that used establish_connection you must surround your code with a cache block:
 
     MyOtherConnectionClass.cache {

data/lib/connection_manager/helpers/abstract_adapter_helper.rb

@@ -6,7 +6,7 @@ module ConnectionManager
 
     # Determines if connection supports cross database queries
     def cross_database_support?
-      (@config[:cross_database_support] || @config[:adapter].match(/(mysql)|(postgres)|(sqlserver)/i))
+      @cross_database_support ||= (@config[:cross_database_support] || @config[:adapter].match(/(mysql)|(postgres)|(sqlserver)/i))
     end
     alias :cross_schema_support? :cross_database_support?
 
@@ -32,31 +32,28 @@ module ConnectionManager
     end
 
     def slave_keys
-      return @config[:slaves].collect{|r| r.to_sym} if @config[:slaves]
-      []
+       @slave_keys ||= (@config[:slaves] ? @config[:slaves].collect{|r| r.to_sym} : [] )
     end
 
     def master_keys
-      return @config[:masters].collect{|r| r.to_sym} if @config[:masters]
-      []
+      @master_keys ||= (@config[:masters] ? @config[:masters].collect{|r| r.to_sym} : [])
     end
 
     if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR <= 1
 
       # Returns the schema for a give table. Returns nil of multiple matches are found  
       def fetch_table_schema(table_name)
+        return nil unless cross_database_support?
         sql = "SELECT table_schema FROM INFORMATION_SCHEMA.TABLES WHERE table_name = '#{table_name}'"
-        found = nil
         results = execute(sql, 'SCHEMA')
         found = results.to_a
-        if (found.length == 1)
-          found = found[0][0]
-        end
-        found
+        return found[0][0] if (found.length == 1)
+        nil
       end
 
       # Returns table_schema.table_name for the given table. Returns nil if multiple matches are found
       def fetch_full_table_name(table_name)
+        return nil unless cross_database_support?
         return table_name if (table_name.to_s.match(/(^$)|(\.)/))
         sql = "SELECT CONCAT(table_schema,'.',table_name) FROM INFORMATION_SCHEMA.TABLES WHERE table_name = '#{table_name}'"
         found = nil
@@ -73,6 +70,7 @@ module ConnectionManager
       
       # Returns the schema for a give table. Returns nil of multiple matches are found      
       def fetch_table_schema(table_name)
+        return nil unless cross_database_support?
         sql = "SELECT table_schema FROM INFORMATION_SCHEMA.TABLES WHERE table_name = '#{table_name}'"
         execute_and_free(sql, 'SCHEMA') do |result|
           found = result.to_a
@@ -83,6 +81,7 @@ module ConnectionManager
 
       # Returns table_schema.table_name for the given table. Returns nil if multiple matches are found
       def fetch_full_table_name(table_name)
+        return nil unless cross_database_support?
         return table_name if (table_name.to_s.match(/(^$)|(\.)/))
         sql = "SELECT CONCAT(table_schema,'.',table_name) FROM INFORMATION_SCHEMA.TABLES WHERE table_name = '#{table_name}'"
         execute_and_free(sql, 'SCHEMA') do |result|

data/lib/connection_manager/replication.rb

@@ -10,10 +10,6 @@ module ConnectionManager
     def replication_methods
       @replication_methods ||= HashWithIndifferentAccess.new
     end
-    
-    def replicant_classes
-      @replicant_classes ||= HashWithIndifferentAccess.new
-    end
        
     # Is this class replicated
     def replicated?
@@ -42,7 +38,6 @@ module ConnectionManager
         connections = connection.replication_keys(options[:type]) if connections.blank?
         set_replications_to_method(connections,options[:name])
         build_repliciation_class_method(options)
-        build_replication_association_class(options)
         build_query_method_alias_method(options[:name])
         build_repliciation_instance_method(options[:name])
         options[:name]
@@ -98,37 +93,6 @@ module ConnectionManager
       end
       STR
     end
-    
-    # Builds a class within the model with the name of replication method. Use this
-    # class as the :class_name options for associations when it is necessary to
-    # ensure eager loading uses a replication connection.
-    # 
-    # EX:
-    # 
-    #   class Foo < ActiveRecord::Base
-    #     belongs_to :user
-    #     replicated # use default name .slaves
-    #   end
-    #   
-    #   class MyClass < ActiveRecord::Base
-    #     has_many :foos
-    #     has_many :foo_slaves, :class_name => 'Foo::Slaves'
-    #     replicated
-    #   end
-    #   
-    #   a = MyClass.include(:foo_slaves).first
-    #   a.foo_slaves => [<Foo::Slave1ConnectionDup...>,<Foo::Slave1ConnectionDup...>...]
-    def build_replication_association_class(options)
-      class_eval <<-STR
-        class #{options[:name].titleize}
-          class << self
-            def method_missing(name, *args)
-              #{self.name}.#{options[:name]}.klass.send(name, *args)
-            end
-          end
-        end
-      STR
-    end
        
     # Build a query method with the name of our replication method. This method 
     # uses the relation.klass to fetch the appropriate connection, ensuring the

data/lib/connection_manager/using.rb

@@ -1,88 +1,53 @@
 require 'active_support/core_ext/module/delegation'
 module ConnectionManager
   module Using
-    module ClassMethods
+    module Relation
 
-      # We use dup here because its just too tricky to make sure we override
-      # all the methods necessary when using a child class of the model. This
-      # action is lazy and the created sub is named to a constant so we only
-      # have to do it once.
-      def fetch_duplicate_class(connection_class_name)
-        begin
-          return "#{self.name}::#{connection_class_name}Dup".constantize
-        rescue NameError
-          return build_dup_class(connection_class_name)
-        end
+      # Specify connection class to used for query.For
+      # example:
+      #
+      # users = User.using(MySlaveConnection).first
+      def using(connection_class_name)
+        @klass = ConnectionManager::Using::Proxy.new(@klass,connection_class_name)
+        self
       end
+    end
 
-      private
-      # Modifies the dup class to use the connection class connection.
-      # We want to use the current class table name, but the connection
-      # class database as the prefix, useful when shards but normally
-      # should be the same. We also want the superclass method to
-      # return the connection class as AR sometimes uses the the superclass
-      # connection
-      def build_dup_class(connection_class_name)
-        use_database(self.current_database_name) # make sure we are consistent from super to dup
-        con_class = connection_class_name.constantize
-        db_name = con_class.current_database_name
-        dup_klass = dup
-        dup_klass.class_eval <<-STR
-        self.use_database('#{db_name}',{:table_name => '#{table_name}'})
-        class << self
-          def model_name
-            #{self.name}.model_name
-          end
-          def connection_class
-            #{connection_class_name}
-          end
-          def connection
-            connection_class.connection
-          end
-          def superclass
-            connection_class
-          end
-        end
-        STR
-
-        self.const_set("#{connection_class_name}Dup", dup_klass)
-        "#{self.name}::#{connection_class_name}Dup".constantize
+    class Proxy
+      attr_accessor :klass, :connection_class
+      
+      def initialize(klass,connection_class)
+        @klass = klass  # the @klass insance from an ActiveRecord::Relation
+        @connection_class = (connection_class.is_a?(String) ? connection_class.constantize : connection_class)
       end
-    end
 
-    # Instance method for casting to a duplication class
-    def using(connection_class)
-      becomes(self.class.using(connection_class).klass)
-    end
+      # Use the connection from the connection class
+      def connection
+        ConnectionManager.logger.info "Using proxy connection: #{@connection_class.name} for #{@klass.name}" if ConnectionManager.logger
+        @connection_class.connection
+      end
 
-    def self.included(host_class)
-      host_class.extend(ClassMethods)
-    end
-  end
-end
+      # Make sure we return the @klass superclass,
+      # which used through the query building code in AR
+      def superclass
+        @klass.superclass
+      end
 
-module ActiveRecord
-  # = Active Record Relation
-  class Relation
-   if ActiveRecord::VERSION::MAJOR == 4
-      def using(connection_class_name)
-        d = @klass.fetch_duplicate_class(connection_class_name)
-        self.instance_variable_set(:@arel_table, d.arel_table)
-        self.instance_variable_set(:@klass, d)
-        self
+      # 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
+      # are used.
+      def method_missing(name, *args, &blk)
+        @klass.send(name, *args,&blk)
       end
-    else
-      def using(connection_class_name)
-        d = @klass.fetch_duplicate_class(connection_class_name)
-        rel = clone
-        rel.instance_variable_set(:@arel_table, d.arel_table)
-        rel.instance_variable_set(:@klass, d)
-        rel
+
+      def respond_to?(method_name, include_private = false)
+        @klass.respond_to?(method_name) || super
       end
     end
   end
 end
-
+ActiveRecord::Relation.send(:include,ConnectionManager::Using::Relation)
 module ActiveRecord
   class Base
     class << self

data/lib/connection_manager/version.rb

@@ -1,3 +1,3 @@
 module ConnectionManager
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end

data/lib/connection_manager.rb

@@ -15,12 +15,15 @@ module ConnectionManager
   ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include,(ConnectionManager::AbstractAdapterHelper))
   ActiveRecord::Base.extend(ConnectionManager::ConnectionHelpers) 
   ActiveRecord::Base.extend(ConnectionManager::ConnectionBuilder)
-  ActiveRecord::Base.send(:include,ConnectionManager::Using)
   ActiveRecord::Base.extend(ConnectionManager::Replication)
   ActiveRecord::Base.extend(ConnectionManager::Shards)
   
   ActiveSupport.on_load(:active_record) do
     ActiveRecord::Base.build_connection_classes
   end
+
+  def self.logger
+    @logger ||= ActiveRecord::Base.logger
+  end
 end
 

data/spec/helpers/database_spec_helper.rb

@@ -22,12 +22,12 @@ end
 #Put all the test migrations here
 class TestMigrations < ActiveRecord::Migration
   # all the ups
-  def self.up(connection_name='test', user_connection_name='cm_user_test')
-    ActiveRecord::Base.establish_connection(connection_name)
+  def self.up
+    ActiveRecord::Base.establish_connection(:test)
     begin
       create_table "#{ActiveRecord::Base.schema_name}.foos" do |t|
         t.string :name
-        t.integer :user_id
+        t.integer :cm_user_id
       end
     rescue => e
       puts "tables failed to create: #{e}"
@@ -76,21 +76,31 @@ class TestMigrations < ActiveRecord::Migration
       puts "tables failed to create: #{e}"
     end
 
-    ActiveRecord::Base.establish_connection(user_connection_name)
+    ActiveRecord::Base.establish_connection(:cm_user_test)
     begin
-      create_table :users do |t|
+      create_table :cm_users do |t|
         t.string :name
       end
     rescue => e
       puts "tables failed to create: #{e}"
     end
 
-    ActiveRecord::Base.establish_connection(connection_name)
+    # Table is in more than 1 schema
+    begin
+      create_table "#{ActiveRecord::Base.schema_name}.types" do |t|
+        t.string :name
+        t.timestamps
+      end
+    rescue => e
+      puts "tables failed to create: #{e}"
+    end
+
+    ActiveRecord::Base.establish_connection(:test)
   end
 
   # all the downs
   def self.down(connection_name='test',user_connection_name='cm_user_test')
-    ActiveRecord::Base.establish_connection(connection_name)
+    ActiveRecord::Base.establish_connection(:test)
     [:foos,:fruits,:baskets,:fruit_baskets,:regions,:types].each do |t|
       begin
         drop_table t
@@ -98,14 +108,14 @@ class TestMigrations < ActiveRecord::Migration
         puts "tables were not dropped: #{e}"
       end
     end
-    ActiveRecord::Base.establish_connection(user_connection_name)
-    begin
-      [:users].each do |t|
+    ActiveRecord::Base.establish_connection(:cm_user_test)
+    [ :cm_users, :types].each do |t|
+      begin
         drop_table t
+      rescue => e
+        puts "tables were not dropped: #{e}"
       end
-    rescue => e
-      puts "tables were not dropped: #{e}"
     end
-    ActiveRecord::Base.establish_connection(connection_name)
+    ActiveRecord::Base.establish_connection(:test)
   end
 end

data/spec/helpers/models_spec_helper.rb

@@ -31,18 +31,22 @@ class Region < ActiveRecord::Base
   #replicated
 end
 
-class Type < ActiveRecord::Base
-  
-end
+class Type < ActiveRecord::Base;end
 
 class SouthernFruit < Fruit
-  self.table_name = 'fruits'  
+  self.table_name = 'fruits'
 end
 
-class ModelsHelper
-  def self.models
-    ["Basket", "Fruit", "FruitBasket", "Region","SouthernFruit", "Type"]
-  end 
+class CmUser < ActiveRecord::Base
+  has_many :foos
 end
 
+class Foo < ActiveRecord::Base
+  belongs_to :cm_user
+end
 
+class ModelsHelper
+  def self.models
+    ["Basket", "Fruit", "FruitBasket", "Region","SouthernFruit", "Type", "Foo", "CmUser"]
+  end
+end

data/spec/lib/patches/cross_schema_path_spec.rb

@@ -1,5 +1,20 @@
 require 'spec_helper'
-describe ActiveRecord::ConnectionAdapters::Mysql2Adapter do
+describe  ActiveRecord::ConnectionAdapters::AbstractAdapter do
+
+  describe '#fetch_table_schema' do
+    context "table is unique in DMS" do
+      it "should return a string consisting of the schema name, a '.' and the table_name" do
+        Fruit.connection.fetch_table_schema('fruits').should eql('cm_test')
+      end
+    end
+
+    context "table is not unique in DMS" do
+      it "should return a string consisting of the schema name, a '.' and the table_name" do
+        Fruit.connection.fetch_table_schema('type').should eql(nil)
+      end
+    end
+  end
+
   describe '#fetch_full_table_name' do
     it "should return a string consisting of the schema name, a '.' and the table_name" do
       Fruit.connection.fetch_full_table_name('fruits').should eql('cm_test.fruits')
@@ -10,7 +25,7 @@ describe ActiveRecord::ConnectionAdapters::Mysql2Adapter do
     it "should return true for unquoted full_names" do
       Fruit.connection.table_exists?('cm_test.fruits').should be_true
     end
-     it "should return true for table only names" do
+    it "should return true for table only names" do
       Fruit.connection.table_exists?('fruits').should be_true
     end
   end
@@ -21,4 +36,39 @@ describe ActiveRecord::Base do
       Fruit.arel_table.name.should eql('cm_test.fruits')
     end
   end
+
+  context "Cross Schema Joins" do
+    before :each do
+      @user = CmUser.new(:name => "Testing")
+      @user.save
+      @foo = Foo.new(:cm_user_id => @user.id)
+      @foo.save
+    end
+
+    describe '#joins' do
+      it "should work" do
+        @user.foos.blank?.should be_false
+        found = Foo.joins(:cm_user).select('cm_users.name AS user_name').where('cm_users.id = ?',@user.id).first
+        found.user_name.blank?.should be_false
+      end
+    end
+    describe '#includes' do
+      before(:each) do
+        @user.foos.blank?.should be_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
+      end
+      it "should return a results" do
+        @found.should be_a(Foo) # Make sure results are returns
+      end
+      it "should loan associations" do
+        if @found.respond_to?(:association)
+          @found.association(:cm_user).loaded?.should be_true
+        else
+          @found.cm_user.loaded?.should be_true
+        end
+      end
+    end
+  end
 end

data/spec/lib/replication_spec.rb

@@ -28,7 +28,6 @@ describe ConnectionManager::Replication do
         f = FactoryGirl.create(:fruit)
         Fruit.replicated(:name => 'fizzle')
         ActiveRecord::QueryMethods.instance_methods.include?(:fizzle).should be_true
-        Fruit.where(:id => f.id).fizzle.first.should_not eql(Fruit.where(:id => f.id).first)
       end
 
       it "should return an ActiveRecord::Relation" do
@@ -86,72 +85,4 @@ describe ConnectionManager::Replication do
       Fruit.replicated?.should be_true
     end
   end
-
-
-
-  #ConnectionManager::Connections.build_connection_classes(:env => 'test')
-  class CmFooSlaveConnection < ActiveRecord::Base
-    establish_managed_connection(:slave_1_cm_test)
-  end
-
-  class CmUserConnection < ActiveRecord::Base
-    establish_managed_connection(:cm_user_test)
-  end
-
-  class SlaveCmUserConnection < ActiveRecord::Base
-    establish_managed_connection(:slave_1_cm_user_test)
-  end
-
-  class User < CmUserConnection
-    has_many :foos
-    has_many(:foo_slaves, :class_name => "Foo::Slaves")
-    replicated('SlaveCmUserConnection')
-
-  end
-
-  class Foo < ActiveRecord::Base
-    belongs_to :user
-    replicated("CmFooSlaveConnection")
-  end
-
-  context "eager loading (#includes)" do
-    before :each do
-      @user = User.new(:name => "Testing")
-      @user.save
-      @foo = Foo.new(:user_id => @user.id)
-      @foo.save
-    end
-
-    # We'd like this to happen magically some day. Possible in 3.2
-    it "should eager load with replication instances" #do
-    #      user = User.slaves.includes(:foos).where(:id => @user.id).first
-    #      user.foos.first.should_not be_kind_of(Foo)
-    #    end
-
-    context "specifically defined replication association" do
-      it "should eager load with replication instances" do
-        user = User.slaves.includes(:foo_slaves).where(:id => @user.id).first
-        user.foo_slaves.first.should_not be_kind_of(Foo)
-      end
-    end
-  end
-  context "cross database joins" do
-    before :each do
-      @user = User.new(:name => "Testing")
-      @user.save
-      @foo = Foo.new(:user_id => @user.id)
-      @foo.save
-    end
-
-    it "should work" do
-      @user.foos.blank?.should be_false
-      found = Foo.select('users.name AS user_name').joins(:user).where(:id => @foo.id).first
-      found.user_name.blank?.should be_false
-    end
-
-    it "should work with replication" do
-      found = Foo.slaves.select('foos.*, users.name AS user_name').joins(:user).where(:id => @foo.id).first
-      found.user.blank?.should be_false
-    end
-  end
 end

data/spec/lib/using_spec.rb

@@ -4,11 +4,6 @@ class CmFooSlaveConnection < ActiveRecord::Base
 end
 
 describe ConnectionManager::Using do
-  
-  it "should add sub class to current class with the name of the connection" do
-    Fruit.send(:fetch_duplicate_class,"CmFooSlaveConnection")
-    lambda { "Fruit::CmFooSlaveConnectionDup".constantize}.should_not raise_error
-  end
 
   describe '#using' do
     it "should return an ActiveRecord::Relation" do
@@ -17,22 +12,26 @@ describe ConnectionManager::Using do
     it "should change the connection" do
       Fruit.using("CmFooSlaveConnection").connection.config.should_not eql(Fruit.connection.config)
     end
-  
+
     it "should create the exact same sql if called from model or from relation" do
       class_sql = Fruit.using("CmFooSlaveConnection").where(:name => "malarky").to_sql
       relation_sql = Fruit.where(:name => "malarky").using("CmFooSlaveConnection").to_sql
       class_sql.should eql(relation_sql)
     end
-  
+
     it "should have the same connection if called from model or from relation" do
       Fruit.where(:name => "malarky").using("CmFooSlaveConnection").connection.config.should eql(
-        Fruit.using("CmFooSlaveConnection").where(:name => "malarky").connection.config)
+      Fruit.using("CmFooSlaveConnection").where(:name => "malarky").connection.config)
       Fruit.using("CmFooSlaveConnection").where(:name => "malarky").connection.config.should_not eql(
-        Fruit.where(:name => "malarky").connection.config)
+      Fruit.where(:name => "malarky").connection.config)
       Fruit.where(:name => "malarky").using("CmFooSlaveConnection").connection.config.should_not eql(
-        Fruit.where(:name => "malarky").connection.config)
+      Fruit.where(:name => "malarky").connection.config)
+    end
+
+    it "should return same record" do
+      fruit = FactoryGirl.create(:fruit)
+      Fruit.using("CmFooSlaveConnection").where(:id => fruit.id).first.should eql(fruit)
     end
   end
 end
-  
 

data/spec/spec_helper.rb

@@ -16,24 +16,22 @@ end
 TestMigrations.down
 TestMigrations.up
 FactoryGirl.find_definitions
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
 RSpec.configure do |config|
-  config.mock_with :mocha 
+  config.mock_with :mocha
   # Loads database.yml and establishes primary connection
   # Create tables when tests are completed
   config.before(:suite) {
-    require 'helpers/models_spec_helper.rb'    
-  }  
+    require 'helpers/models_spec_helper.rb'
+  }
   # Drops tables when tests are completed
   config.after(:suite){
     TestDB.clean
-  } 
+  }
   # Make sure every test is isolated.
   config.before(:each){
-    ModelsHelper.models.each{|m| Object.send(:remove_const, m)}  
+    ModelsHelper.models.each{|m| Object.send(:remove_const, m)}
     load 'helpers/models_spec_helper.rb'
     FactoryGirl.reload
   }
-    
 end
-
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: connection_manager
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Joshua Mckinney
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-24 00:00:00.000000000 Z
+date: 2014-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord