connection_manager 0.2.6 → 0.3.0

data/lib/connection_manager/connections.rb

@@ -1,124 +0,0 @@
-module ConnectionManager
-  class Connections
-    class << self
-      @connection_keys
-      @all
-      @secondary_connections
-      @env 
-    
-      def env
-        @env ||= fetch_env
-        @env
-      end
-    
-      def env=env
-        @env = env
-      end
-    
-      def env_regex(with_underscore=true)
-        s = "#{env}$"
-        s.insert(0,"\_") if with_underscore
-        Regexp.new("(#{s})")
-      end
-      
-      # Get the current environment if defined
-      # 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)
-        "development"
-      end
-    
-      # Grab only thoses connections that correspond to the current env. If env
-      # is blank it grabs all the connection keys
-      def connection_keys
-        @connection_keys ||= ActiveRecord::Base.configurations.keys.
-          select{|n| n.match(env_regex(false))}
-      end
-    
-      # Contains all the connection classes built
-      def all
-        @all ||= []
-      end
-    
-      # Holds 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)
-        clean_db_name(ActiveRecord::Base.configurations[name_from_yml]['database'])
-      end
-      
-      def clean_sqlite_db_name(name,remove_env=true)
-        new_name = "#{name}".gsub(/(\.sqlite3$)/,'')  
-        new_name = new_name.split("/").last 
-        new_name.gsub!(env_regex,'') if remove_env
-        new_name
-      end
-      
-      def clean_db_name(name)
-        new_name = "#{name}".gsub(env_regex(false),'')
-        if new_name.blank?
-          new_name = "#{database_name_from_yml(name)}"
-        end  
-        new_name = clean_sqlite_db_name(new_name)
-        new_name.gsub(/\_$/,'')
-      end
-      
-      # 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_db_name(name_from_yml)
-        new_class_name = new_class_name.gsub(/\_/,' ').titleize.gsub(/ /,'')
-        new_class_name << "Connection"
-        new_class_name
-      end 
-     
-      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_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 available_secondary_connections(rep_collection_key)
-        secondary_connections[(rep_collection_key.gsub(env_regex,'')).to_sym]
-      end
-    
-      # Sets class instance attributes, then builds connection classes, while populating
-      # available_connctions and replication_connection
-      def initialize(options={})  
-        options.each do |k,v|
-          send("#{k.to_s}=",v)
-        end     
-        connection_keys.each do |connection|
-          new_connection = connection_class_name(connection)
-          add_secondary_connection(connection,new_connection)        
-          build_connection_class(new_connection,connection) 
-        end
-        all
-      end 
-    
-      # 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)
-        klass = Class.new(ActiveRecord::Base) do         
-          self.abstract_class = true
-        end
-        new_connection_class = Object.const_set(class_name, klass)
-        new_connection_class.table_name_prefix=("#{ActiveRecord::Base.configurations[connection_key]['database']}.")
-        new_connection_class.establish_connection(connection_key)       
-        (const_set class_name, new_connection_class)
-        all << class_name
-      end
-    end
-  end
-end

data/lib/connection_manager/method_recorder.rb

@@ -1,57 +0,0 @@
-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/secondary_connection_builder.rb

@@ -1,180 +0,0 @@
-module ConnectionManager
-  module SecondaryConnectionBuilder
-   
-    def database_name
-      "#{connection.instance_variable_get(:@config)[:database].to_s}"
-    end
-    
-    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}"
-      else
-        new_options[:class_name] = "#{new_options[:class_name]}::#{class_name}"
-      end
-      
-      if [:has_one,:has_many].include?(method) && new_options[:foreign_key].blank? 
-        new_options[:foreign_key] = "#{table_name.singularize}_id"
-      end     
-      new_options
-    end
-    
-    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}, #{secondary_association_options(method,association,class_name,options)};" 
-            end
-          end
-        end
-      end
-      str
-    end
-    
-    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.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 shard(*settings)   
-      options = {:name => "shard", :readonly => false, :shards => true}.merge(settings.extract_options!) 
-      build_secondary_connections(options)
-    end
-    
-    def child_connection_class?
-      false
-    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 secondary instance, 'database_name' is the actual 
-    # name of the database and '_test' is the Rails environment
-    def build_secondary_connections(options={})   
-      unless name.match(/\:\:/)
-        connection_classes = secondary_connection_classes(options)  
-        sub_classes = []
-        if connection_classes.blank?
-          raise ArgumentError, " a secondary connection was not found. Check your database.yml."
-        else   
-          connection_methods = []
-          connection_classes.each do |c|
-            under_scored = c.underscore
-            method_name = under_scored.split("_")[0]
-            method_name = method_name.insert(method_name.index(/\d/),"_")
-            class_name = method_name.classify
-            connection_methods << method_name.to_sym
-#            set_table_name_for_joins
-            build_secondary_class(class_name,c,options)
-            build_single_secondary_method(method_name,class_name)            
-            sub_classes << "#{self.name}::#{class_name}".constantize if options[:shards]
-          end
-        end
-        build_slaves_method(connection_methods)  if options[:replication]
-        build_shards_method(sub_classes)  if options[:shards]
-      end
-    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 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. 
-    # 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_2 database
-    #   User::Shard1.where(:id => 2).first => returns results from slave_1 database
-    def build_secondary_class(class_name,connection_name,options)
-      klass = Class.new(self) do
-        class << self
-          def model_name
-            ActiveModel::Name.new(superclass)
-          end         
-          def child_connection_class?
-            true  
-          end
-        end
-        
-        if (options[:name] == "readonly" || options[:readonly])
-          def readonly?
-            true
-          end
-        end
-      end 
- 
-      sub_class = const_set(class_name, klass)
-      sub_class.build_secondary_associations(class_name)      
-      sub_class.class_eval <<-STR, __FILE__, __LINE__
-        class << self
-          def connection
-            Connections::#{connection_name}.connection
-          end
-        end
-      STR
-      connection_sub_classes << sub_class
-      sub_class
-    end
-    
-    def connection_sub_classes
-      @connection_sub_classes ||= []
-    end
-    
-    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_secondary_method(method_name,class_name)
-      self.class.instance_eval do       
-        define_method method_name.to_s do
-          "#{name}::#{class_name}".constantize
-        end
-      end
-    end
-    
-    # add a class method that shifts through available connections methods
-    # on each call.
-    # Usage:
-    #   User.slave.where(:id => 2).first => can return results from slave_1 or slave_2 
-    def build_slaves_method(connection_methods)
-      @connection_methods = connection_methods
-      self.class.instance_eval do       
-        define_method 'slaves' do
-          current = @connection_methods.shift
-          @connection_methods << current
-          send(current)
-        end
-        alias_method :slave, :slaves
-      end
-    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_classes)    
-      self.class.instance_eval do
-        define_method 'shards' do
-          ConnectionManager::MethodRecorder.new(connection_classes)
-        end
-      end
-    end
-  end
-end

data/spec/integration/secondary_connection_builder_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-
-# Tests for associations build form replication.
-
-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.secondary_connections.clear
-      
-    #Initialize
-    ConnectionManager::Connections.initialize(:env => 'test')
-    
-    # Add Replication to models
-    Fruit.replicated
-    Basket.replicated
-    FruitBasket.replicated
-    Region.replicated :readonly => false
-  end
-  
-  context "models that have been replicated" do
-    it "should respond to slave_1" do
-      Fruit.respond_to?(:slave_1).should be_true
-    end
-    
-    it "should respond to slave" do
-      Fruit.respond_to?(:slave).should be_true
-    end
-    
-    it "should have a subclass of Slave1" do
-      defined?(Fruit::Slave1).should be_true
-    end
-    
-    context "subclasses" do
-      it "should have a superclass of the parent class" do
-        
-        Fruit::Slave1.superclass.should eql(Fruit)
-      end
-    end
-  end
-  
-  context "readonly" do
-  end
-  
-  context "slave" do
-    context('belongs_to') do
-      it "should return the same belongs to object as master" do
-        fruit = Factory.create(:fruit)      
-        slave_fruit = Fruit.slave.where(:id => fruit.id).first
-        slave_fruit.region.id.should eql(fruit.region.id)
-      end
-    end
-  
-    context('has_one') do
-      it "should return the same has_on object as master" do
-        region = Factory.create(:fruit).region
-        slave_region = Region.slave.where(:id => region.id).first
-        slave_region.fruit.id.should eql(region.fruit.id)
-      end
-    end
-  
-    context('has_many') do
-      it "should return the same has_many objects as master" do
-        fruit = Factory.create(:fruit)
-        3.times do
-          Factory.create(:fruit_basket, :fruit_id => fruit.id)
-        end
-        fruit.fruit_baskets.length.should eql(3)
-        slave_fruit = Fruit.slave.where(:id => fruit.id).first     
-        slave_fruit.fruit_baskets.length.should eql(fruit.fruit_baskets.length) 
-        slave_fruit.fruit_baskets.collect(&:id).should eql(fruit.fruit_baskets.collect(&:id))      
-      end
-    end
-   
-    context('has_many :through') do   
-      it "should return the same fruit as master" do
-        basket = Factory.create(:fruit_basket)
-        slave_fruit = Fruit.slave.where(:id => basket.fruit_id).first
-        master_fruit = Fruit.where(:id => basket.fruit_id).first   
-        slave_fruit.basket_ids.should eql(master_fruit.basket_ids)
-      end
-    end
-    context "readonly" do
-     it "should return a readonly object by default" do
-       Factory.create(:fruit)
-       readonly_fruit = Fruit.slave.first
-       readonly_fruit.readonly?.should be_true
-       lambda { readonly_fruit.save }.should raise_error
-     end
-     it "should not return readonly if replicated readonly is to false" do
-       Factory.create(:region)
-       Region.slave.first.readonly?.should be_false
-     end
-   end
-  end
-  context "model_name for slave" do
-    it "should return the supers model_name" do
-      Fruit.slave_1.model_name.should eql(Fruit.model_name)
-    end
-    
-    it "should not interfear with inheritance" do
-      Factory.create(:fruit)
-      class MyFruit < Fruit
-        replicated
-      end
-      Fruit.model_name.should_not eql(MyFruit.model_name)
-      MyFruit.model_name.should eql("MyFruit")
-      MyFruit.model_name.respond_to?(:plural).should be_true
-      MyFruit.slave_1.model_name.should eql("MyFruit")
-      MyFruit.slave_1.first.class.should eql(MyFruit::Slave1)
-      
-    end
-  end
-end
-

data/spec/lib/associations_spec.rb

@@ -1,30 +0,0 @@
-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
-    Foo.defined_associations.keys.should eql([:belongs_to,:has_many,:has_one]) 
-    Bar.defined_associations.keys.should eql([:has_many])
-  end
-  
-  context "defined_association values" do
-    it "should be an array of association options (which are Arrays as well)" do
-      Foo.defined_associations[:belongs_to].should eql([[:that]])
-      Foo.defined_associations[:has_many].should eql([[:foo_bars],[:bars, {:through=>:foo_bars, :extend=>[]}]]) # when options are present active_record addes the :extend option defaulted to []
-      Foo.defined_associations[:has_one].should eql([[:noob]])
-    end
-  end
-  
-end
-

data/spec/lib/connections_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-describe ConnectionManager::Connections do
-  # For all tests set the env to "test"
-  before(:all) do
-    ConnectionManager::Connections.env = "test"
-  end
-  context '#clean_sqlite_db_name' do
-    it "should remove the directory .sqlite3, Rails.env from the string" do
-      ConnectionManager::Connections.clean_sqlite_db_name("db/my_database_test.sqlite3").should eql("my_database")
-    end
-  end
-  
-  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_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_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_db_name("test").should eql("my_database")
-      end
-    end
-  end
-  
-  context '#connection_class_name' do
-    
-    it "should return a string for a class name appended with 'Connection' " do
-      ConnectionManager::Connections.connection_class_name("my_database").should eql("MyDatabaseConnection")
-    end
-    it "should return remove the appended rails env" do
-      ConnectionManager::Connections.connection_class_name("my_database_test").should eql("MyDatabaseConnection")
-    end
-    it "should handle sqlite database names correctly " do
-      ConnectionManager::Connections.connection_class_name("db/my_database_test.sqlite3").should eql("MyDatabaseConnection")
-    end
-    it "should use the database name from the database.yml if supplied string is only is only the Rails.env" do
-      ConnectionManager::Connections.stubs(:database_name_from_yml).returns("my_test_test")
-      ConnectionManager::Connections.connection_class_name("test").should eql("MyTestConnection")
-    end
-  end
-  
-   
-  context 'after #initialize' do
-    before(:all) do
-      # Make sure connections recreated in other tests do not presist to tests tests
-      ConnectionManager::Connections.all.clear
-      ConnectionManager::Connections.secondary_connections.clear
-      
-      #Initialize
-      ConnectionManager::Connections.initialize(:env => 'test')
-    end
-    
-    context '#all' do
-      it "should return the database.yml entries for the current rails environment" do
-        ConnectionManager::Connections.all.should eql(["CmConnection",
-            "Slave1CmConnection", "Slave2CmConnection", "Shard1CmConnection"])
-      end
-    end
-    
-    context '#secondary_connections' do
-      it "should return a hash where the keys are the generic undescored names for all connections" do
-        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.secondary_connections.values.first
-        first_value.class.should eql(Array)
-        defined?((ConnectionManager::Connections.class_eval(first_value[0]))).should be_true
-      end
-    end
-    
-    context '#build_connection_class' do
-      before(:all) do
-        ConnectionManager::Connections.build_connection_class("MyConnectionClass", 'test')
-      end
-      it "should add a class with supplied class name to ConnectionManager::Connections" do
-        defined?(ConnectionManager::Connections::MyConnectionClass).should be_true
-        ConnectionManager::Connections::MyConnectionClass.is_a?(Class).should be_true
-      end
-      it "should have a super class of ActiveRecord::Base" do
-        ConnectionManager::Connections::MyConnectionClass.superclass.should eql(ActiveRecord::Base)
-      end
-    end   
-  end
-end
-

data/spec/lib/method_recorder_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe ConnectionManager::MethodRecorder do
-  before(:all) do
-    TestMigrations.up('shard_1_cm_test')
-    ConnectionManager::Connections.initialize(:env => 'test')
-    class Fruit < ActiveRecord::Base
-      shard(:using => ["shard_1_cm_test"])    
-    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
-  after(:all) do
-    TestMigrations.down('shard_1_cm_test')
-    ActiveRecord::Base.establish_connection('test') 
-  end
-end