db-charmer 1.3.1

data/.gitignore

@@ -0,0 +1,2 @@
+/doc
+/pkg

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2009, Alexey Kovyrin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Makefile

@@ -0,0 +1,2 @@
+doc/files/README_rdoc.html:	README.rdoc
+	rdoc README.rdoc

data/README.rdoc

@@ -0,0 +1,245 @@
+= DB Charmer - ActiveRecord Connection Magic Plugin
+
++DbCharmer+ is a simple yet powerful plugin for ActiveRecord that does a few things:
+
+1. Allows you to easily manage AR models' connections (+switch_connection_to+ method)
+2. Allows you to switch AR models' default connections to a separate servers/databases
+3. Allows you to easily choose where your query should go (<tt>Model.on_db</tt> methods)
+4. Allows you to automatically send read queries to your slaves while masters would handle all the updates.
+5. Adds multiple databases migrations to ActiveRecord
+
+
+== Installation
+
+There are two options when approaching db-charmer installation:
+* using gem (recommended)
+* install as a Rails plugin
+
+To install as a gem, add this to your environment.rb:
+
+  config.gem 'kovyrin-db-charmer', :lib => 'db_charmer',
+    :source => 'http://gems.github.com'
+
+And then run the command:
+
+  sudo rake gems:install
+
+To install db-charmer as a Rails plugin use this:
+
+  script/plugin install git://github.com/kovyrin/db-charmer.git
+
+
+== Easy ActiveRecord Connection Management
+
+As a part of this plugin we've added +switch_connection_to+ method that accepts many different kinds 
+of db connections and uses them on a model. We support:
+
+1. Strings and symbols as the names of connection configuration blocks in database.yml.
+2. ActiveRecord models (we'd use connection currently set up on a model).
+3. Database connections (<tt>Model.connection</tt>)
+4. Nil values to reset model to default connection.
+
+Sample code:
+
+  class Foo < ActiveRecord::Model; end
+	
+  Foo.switch_connection_to(:blah)
+  Foo.switch_connection_to('foo')
+  Foo.switch_connection_to(Bar)
+  Foo.switch_connection_to(Baz.connection)
+  Foo.switch_connection_to(nil)
+
+The +switch_connection_to+ method has an optional second parameter +should_exist+ which is true 
+by default. This parameter is used when the method is called with a string or a symbol connection 
+name and there is no such connection configuration in the database.yml file. If this parameter 
+is true, an exception would be raised, if it is false, the error would be ignored and no connection 
+change would happen. This is really useful when in development mode or in tests you do not want to 
+create many different databases on your local machine and just want to put all your tables in one 
+database.
+
+Warning: All the connection switching calls would switch connection *only* for those classes the 
+method called on. You can't call the +switch_connection_to+ method and switch connection for a 
+base class in some hierarchy (for example, you can't switch AR::Base connection and see all your 
+models switched to the new connection, use classic +establish_connection+ instead).
+
+
+== Multiple DB Migrations
+
+In every application that works with many databases, there is need in convenient schema migrations mechanism. 
+
+All Rails users already have this mechanism - rails migrations. So in +DbCharmer+, we've made it possible 
+to seamlessly use multiple databases in Rails migrations.
+
+There are two methods available in migrations to operate on more than one database:
+
+1. Global connection change method - used to switch whole migration to a non-default database.
+2. Block-level connection change method - could be used to do only a part of a migration on a non-default db.
+
+Migration class example (global connection rewrite):
+
+  class MultiDbTest < ActiveRecord::Migration
+     db_magic :connection => :second_db
+   
+     def self.up
+       create_table :test_table, :force => true do |t|
+         t.string :test_string
+         t.timestamps
+       end
+     end
+   
+     def self.down
+       drop_table :test_table
+     end
+   end
+
+Migration class example (block-level connection rewrite):
+
+  class MultiDbTest < ActiveRecord::Migration
+    def self.up
+      on_db :second_db do
+        create_table :test_table, :force => true do |t|
+          t.string :test_string
+          t.timestamps
+        end
+      end
+    end
+  
+    def self.down
+      on_db :second_db { drop_table :test_table }
+    end
+  end
+
+
+By default in development and test environments you could skip this <tt>:second_db</tt> 
+connection from your database.yml files, but in production you'd specify it and 
+get the table created on a separate server and/or in a separate database.
+
+This behaviour is controlled by the <tt>DbCharmer.migration_connections_should_exist</tt> 
+configuration attribute which could be set from a rails initializer.
+
+
+== Using Models in Master-Slave Environments
+
+Master-slave replication is the most popular scale-out technique in medium and large 
+database applications today. There are some rails plugins out there that help rails 
+developers to use slave servers in their models but none of there were flexible enough 
+for us to start using them in a huge application we work on.
+
+So, we've been using ActsAsReadonlyable plugin for a long time and have developed a 
+lots of additions to its code over that time. Since that plugin has been abandoned 
+by its authors, we've decided to collect all of our master-slave code in one plugin 
+and release it for rails 2.2+. +DbCharmer+ adds the following features to Rails models:
+
+
+=== Auto-Switching all Reads to Slave(s)
+
+When you create a model, you could use <tt>db_magic :slave => :blah</tt> or 
+<tt>db_magic :slaves => [ :foo, :bar ]</tt> commands in your model to set up reads 
+redirection mode when all your find/count/exist/etc methods will be reading data 
+from your slave (or a bunch of slaves in a round-robin manner). Here is an example:
+
+  class Foo < ActiveRecord::Base
+    db_magic :slave => :slave01
+  end
+
+  class Bar < ActiveRecord::Base
+    db_magic :slaves => [ :slave01, :slave02 ]
+  end
+
+
+=== Default Connection Switching
+
+If you have more than one master-slave cluster (or simply more than one database) 
+in your database environment, then you might want to change the default database 
+connection of some of your models. You could do that by using 
+<tt>db_magic :connection => :foo</tt> call from your models. Example:
+
+  class Foo < ActiveRecord::Base
+    db_magic :connection => :foo
+  end
+
+Sample model on a separate master-slave cluster (so, separate main connection + 
+a slave connection):
+
+  class Bar < ActiveRecord::Base
+    db_magic :connection => :bar, :slave => :bar_slave
+  end
+
+=== Per-Query Connection Management
+
+Sometimes you have some select queries that you know you want to run on the master. 
+This could happen for example when you have just added some data and need to read 
+it back and not sure if it made it all the way to the slave yet or no. For this 
+situation an few others there are a few methods we've added to ActiveRecord models:
+
+1) +on_master+ - this method could be used in two forms: block form and proxy form. 
+In the block form you could force connection switch for a block of code:
+
+  User.on_master do
+    user = User.find_by_login('foo')
+    user.update_attributes!(:activated => true)
+  end
+
+In the proxy form this method could be used to force one query to be performed on 
+the master database server:
+
+  Comment.on_master.last(:limit => 5)
+  User.on_master.find_by_activation_code(code)
+  User.on_master.exists?(:login => login, :password => password)
+
+2) +on_slave+ - this method is used to force a query to be run on a slave even in 
+situations when it's been previously forced to use the master. If there is more 
+than one slave, one would be selected randomly. Tis method has two forms as 
+well: block and proxy.
+
+3) <tt>on_db(connection)</tt> - this method is what makes two previous methods possible. 
+It is used to switch a model's connection to some db for a short block of code 
+or even for one statement (two forms). It accepts the same range of values as 
+the +switch_connection_to+ method does. Example:
+
+  Comment.on_db(:olap).count
+  Post.on_db(:foo).find(:first)
+
+
+=== Associations Connection Management
+
+ActiveRecord models can have associations and with their own connections and it becomes
+pretty hard to manage connections in chained calls like <tt>User.posts.count</tt>. With
+class-only connection switching methods this call would look like the following if we'd
+want to count posts on a separate database:
+
+  Post.on_db(:olap) { User.posts.count }
+
+Apparently this is not the best way to write the code and we've implemented <tt>on_*</tt>
+methods on associations as well so you could do things like this:
+
+  @user.posts.on_db(:olap).count
+  @user.posts.on_slave.find(:title => 'Hello, world!')
+
+Notice: Since ActiveRecord associations implemented as proxies for resulting
+objects/collections, it is possible to use our connection switching methods even without
+chained methods:
+
+  @post.user.on_slave - would return post's author
+  @photo.owner.on_slave - would return photo's owner
+
+
+== Documentation
+
+For more information on the plugin internals, please check out the source code. All the plugin's
+code is covered with tests that were placed in a separate staging rails project located at
+http://github.com/kovyrin/db-charmer-sandbox. The project has unit tests for all or at least the
+most of the parts of plugin's code.
+
+
+== What Ruby and Rails implementations does it work for?
+
+We've tested the plugin on MRI 1.8.6 with Rails 2.2 and 2.3. We use it in production on Scribd.com 
+with MRI 1.8.6 and Rails 2.2.
+
+
+== Who are the authors?
+
+This plugin has been created in Scribd.com for our internal use and then the sources were opened for
+other people to use. All the code in this package has been developed by Alexey Kovyrin for Scribd.com
+and is released under the MIT license. For more details, see the LICENSE file.

data/Rakefile

@@ -0,0 +1,16 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = 'db-charmer'
+    gemspec.summary = 'ActiveRecord Connections Magic'
+    gemspec.description = 'ActiveRecord Connections Magic (slaves, multiple connections, etc)'
+    gemspec.email = 'alexey@kovyrin.net'
+    gemspec.homepage = 'http://github.com/kovyrin/db-charmer'
+    gemspec.authors = ['Alexey Kovyrin']
+
+    gemspec.add_dependency('rails', '>= 2.2.0')
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts 'Jeweler not available. Install it with: sudo gem install jeweler'
+end

data/VERSION

@@ -0,0 +1 @@
+1.3.1

data/db-charmer.gemspec

@@ -0,0 +1,57 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{db-charmer}
+  s.version = "1.3.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alexey Kovyrin"]
+  s.date = %q{2009-10-09}
+  s.description = %q{ActiveRecord Connections Magic (slaves, multiple connections, etc)}
+  s.email = %q{alexey@kovyrin.net}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "Makefile",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "db-charmer.gemspec",
+     "init.rb",
+     "lib/db_charmer.rb",
+     "lib/db_charmer/active_record_extensions.rb",
+     "lib/db_charmer/association_proxy.rb",
+     "lib/db_charmer/connection_factory.rb",
+     "lib/db_charmer/connection_proxy.rb",
+     "lib/db_charmer/connection_switch.rb",
+     "lib/db_charmer/db_magic.rb",
+     "lib/db_charmer/finder_overrides.rb",
+     "lib/db_charmer/multi_db_migrations.rb",
+     "lib/db_charmer/multi_db_proxy.rb"
+  ]
+  s.homepage = %q{http://github.com/kovyrin/db-charmer}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{ActiveRecord Connections Magic}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rails>, [">= 2.2.0"])
+    else
+      s.add_dependency(%q<rails>, [">= 2.2.0"])
+    end
+  else
+    s.add_dependency(%q<rails>, [">= 2.2.0"])
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'db_charmer'

data/lib/db_charmer.rb

@@ -0,0 +1,58 @@
+puts "Loading DbCharmer..."
+
+module DbCharmer
+  @@migration_connections_should_exist = Rails.env.production?
+  mattr_accessor :migration_connections_should_exist
+
+  def self.migration_connections_should_exist?
+    !! migration_connections_should_exist
+  end
+
+  @@connections_should_exist = Rails.env.production?
+  mattr_accessor :connections_should_exist
+
+  def self.connections_should_exist?
+    !! connections_should_exist
+  end
+  
+  def self.logger
+    return Rails.logger if defined?(Rails)
+    @logger ||= Logger.new(STDERR)
+  end
+end
+
+puts "Extending AR..."
+
+require 'db_charmer/active_record_extensions'
+require 'db_charmer/connection_factory'
+require 'db_charmer/connection_proxy'
+require 'db_charmer/connection_switch'
+require 'db_charmer/association_proxy'
+require 'db_charmer/multi_db_proxy'
+
+# Enable misc AR extensions
+ActiveRecord::Base.extend(DbCharmer::ActiveRecordExtensions::ClassMethods)
+
+# Enable connections switching in AR
+ActiveRecord::Base.extend(DbCharmer::ConnectionSwitch::ClassMethods)
+
+# Enable connection proxy in AR
+ActiveRecord::Base.extend(DbCharmer::MultiDbProxy::ClassMethods)
+ActiveRecord::Base.extend(DbCharmer::MultiDbProxy::MasterSlaveClassMethods)
+#ActiveRecord::Base.send(:include, DbCharmer::MultiDbProxy::InstanceMethods)
+
+# Enable connection proxy for associations
+ActiveRecord::Associations::AssociationProxy.send(:include, DbCharmer::AssociationProxy::InstanceMethods)
+
+puts "Doing the magic..."
+
+require 'db_charmer/db_magic'
+require 'db_charmer/finder_overrides'
+require 'db_charmer/multi_db_migrations'
+require 'db_charmer/multi_db_proxy'
+
+# Enable multi-db migrations
+ActiveRecord::Migration.extend(DbCharmer::MultiDbMigrations)
+
+# Enable the magic
+ActiveRecord::Base.extend(DbCharmer::DbMagic::ClassMethods)

data/lib/db_charmer/active_record_extensions.rb

@@ -0,0 +1,75 @@
+module DbCharmer
+  module ActiveRecordExtensions
+    module ClassMethods
+
+      def establish_real_connection_if_exists(name, should_exist = false)
+        config = configurations[RAILS_ENV][name.to_s]
+        if should_exist && !config
+          raise ArgumentError, "Invalid connection name (does not exist in database.yml): #{RAILS_ENV}/#{name}"
+        end
+        establish_connection(config) if config
+      end
+
+      #-----------------------------------------------------------------------------
+      @@db_charmer_opts = {}
+      def db_charmer_opts=(opts)
+        @@db_charmer_opts[self.name] = opts
+      end
+
+      def db_charmer_opts
+        @@db_charmer_opts[self.name] || {}
+      end
+
+      #-----------------------------------------------------------------------------
+      @@db_charmer_connection_proxies = {}
+      def db_charmer_connection_proxy=(proxy)
+        @@db_charmer_connection_proxies[self.name] = proxy
+      end
+
+      def db_charmer_connection_proxy
+        @@db_charmer_connection_proxies[self.name]
+      end
+
+      #-----------------------------------------------------------------------------
+      @@db_charmer_slaves = {}
+      def db_charmer_slaves=(slaves)
+        @@db_charmer_slaves[self.name] = slaves
+      end
+
+      def db_charmer_slaves
+        @@db_charmer_slaves[self.name] || []
+      end
+
+      def db_charmer_random_slave
+        return nil unless db_charmer_slaves.any?
+        db_charmer_slaves[rand(db_charmer_slaves.size)]
+      end
+
+      #-----------------------------------------------------------------------------
+      @@db_charmer_connection_levels = Hash.new(0)
+      def db_charmer_connection_level=(level)
+        @@db_charmer_connection_levels[self.name] = level
+      end
+
+      def db_charmer_connection_level
+        @@db_charmer_connection_levels[self.name] || 0
+      end
+
+      def db_charmer_top_level_connection?
+        db_charmer_connection_level.zero?
+      end
+
+      #-----------------------------------------------------------------------------
+      def hijack_connection!
+        return if self.respond_to?(:connection_with_magic)
+        class << self
+          def connection_with_magic
+            db_charmer_connection_proxy || connection_without_magic
+          end
+          alias_method_chain :connection, :magic
+        end
+      end
+
+    end
+  end
+end

data/lib/db_charmer/association_proxy.rb

@@ -0,0 +1,17 @@
+module DbCharmer
+  module AssociationProxy
+    module InstanceMethods
+      def on_db(con, &block)
+        @reflection.klass.on_db(con, self, &block)
+      end
+
+      def on_slave(con = nil, &block)
+        @reflection.klass.on_slave(con, self, &block)
+      end
+
+      def on_master(&block)
+        @reflection.klass.on_master(self, &block)
+      end
+    end
+  end
+end

data/lib/db_charmer/connection_factory.rb

@@ -0,0 +1,38 @@
+module DbCharmer
+  class ConnectionFactory
+    @@connection_classes = {}
+
+    def self.reset!
+      @@connection_classes = {}
+    end
+
+    def self.connect(db_name, should_exist = false)
+      @@connection_classes[db_name.to_s] ||= establish_connection(db_name.to_s, should_exist)
+#      DbCharmer.logger.warn("ConnectionFactory.connect(#{db_name}) = #{@@connection_classes[db_name.to_s]}")
+#      return @@connection_classes[db_name.to_s]
+    end
+
+    def self.establish_connection(db_name, should_exist = false)
+#      DbCharmer.logger.debug("Creating a connection proxy for #{db_name}")
+      abstract_class = generate_abstract_class(db_name, should_exist)
+      DbCharmer::ConnectionProxy.new(abstract_class)
+    end
+
+    def self.generate_abstract_class(db_name, should_exist = false)
+#      DbCharmer.logger.info("Generating abstract connection class for #{db_name}: #{abstract_connection_class_name db_name}")
+
+      module_eval <<-EOF, __FILE__, __LINE__ + 1
+        class #{abstract_connection_class_name db_name} < ActiveRecord::Base
+          self.abstract_class = true
+          establish_real_connection_if_exists(:#{db_name}, #{!!should_exist})
+        end
+      EOF
+
+      abstract_connection_class_name(db_name).constantize
+    end
+
+    def self.abstract_connection_class_name(db_name)
+      "::AutoGeneratedAbstractConnectionClass#{db_name.camelize}"
+    end
+  end
+end

data/lib/db_charmer/connection_proxy.rb

@@ -0,0 +1,11 @@
+module DbCharmer
+  class ConnectionProxy < BlankSlate
+    def initialize(abstract_class)
+      @abstract_connection_class = abstract_class
+    end
+
+    def method_missing(meth, *args, &block)
+      @abstract_connection_class.retrieve_connection.send(meth, *args, &block)
+    end
+  end
+end

data/lib/db_charmer/connection_switch.rb

@@ -0,0 +1,29 @@
+module DbCharmer
+  module ConnectionSwitch
+    module ClassMethods
+      def coerce_to_connection_proxy(conn, should_exist = true)
+        return nil if conn.nil?
+
+        if conn.kind_of?(Symbol) || conn.kind_of?(String)
+          return DbCharmer::ConnectionFactory.connect(conn, should_exist)
+        end
+
+        if conn.respond_to?(:db_charmer_connection_proxy)
+          return conn.db_charmer_connection_proxy
+        end
+
+        if conn.kind_of?(ActiveRecord::ConnectionAdapters::AbstractAdapter)
+          return conn
+        end
+
+        raise "Unsupported connection type: #{conn.class}"
+      end
+
+      def switch_connection_to(conn, require_config_to_exist = true)
+#        puts "DEBUG: Assigning connection proxy for #{self}"
+        self.db_charmer_connection_proxy = coerce_to_connection_proxy(conn, require_config_to_exist)
+        self.hijack_connection!
+      end
+    end
+  end
+end

data/lib/db_charmer/db_magic.rb

@@ -0,0 +1,49 @@
+module DbCharmer
+  module DbMagic
+    module ClassMethods
+      def db_magic(opt = {})
+        # Make sure we could use our connections management here
+        hijack_connection!
+
+        # Should requested connections exist in the config?
+        should_exist = opt[:should_exist] || DbCharmer.connections_should_exist?
+
+        # Main connection management
+        db_magic_connection(opt[:connection], should_exist) if opt[:connection]
+
+        # Set up slaves pool
+        opt[:slaves] ||= []
+        opt[:slaves] << opt[:slave] if opt[:slave]
+        db_magic_slaves(opt[:slaves], should_exist) if opt[:slaves].any?
+        
+        # Setup inheritance magic
+        setup_children_magic(opt)
+      end
+
+    private
+
+      def setup_children_magic(opt)
+        self.db_charmer_opts = opt.clone
+        
+        def self.inherited(child)
+          child.db_magic(self.db_charmer_opts)
+          super
+        end
+      end
+
+      def db_magic_connection(conn, should_exist = false)
+        switch_connection_to(conn, should_exist)
+      end
+
+      def db_magic_slaves(slaves, should_exist = false)
+        self.db_charmer_slaves = slaves.collect do |slave|
+          coerce_to_connection_proxy(slave, should_exist)
+        end
+
+        self.extend(DbCharmer::FinderOverrides::ClassMethods)
+        self.send(:include, DbCharmer::FinderOverrides::InstanceMethods)
+        self.extend(DbCharmer::MultiDbProxy::MasterSlaveClassMethods)
+      end
+    end
+  end
+end

data/lib/db_charmer/finder_overrides.rb

@@ -0,0 +1,47 @@
+module DbCharmer
+  module FinderOverrides
+    module ClassMethods
+      SLAVE_METHODS = [ :find_by_sql, :count_by_sql, :calculate ]
+      MASTER_METHODS = [ :update, :create, :delete, :destroy, :delete_all, :destroy_all, :update_all, :update_counters ]
+
+      SLAVE_METHODS.each do |slave_method|
+        class_eval <<-EOF
+          def #{slave_method}(*args, &block)
+            first_level_on_slave do
+              super(*args, &block)
+            end
+          end
+        EOF
+      end
+
+      MASTER_METHODS.each do |master_method|
+        class_eval <<-EOF
+          def #{master_method}(*args, &block)
+            on_master do
+              super(*args, &block)
+            end
+          end
+        EOF
+      end
+
+    private
+
+      def first_level_on_slave
+        if db_charmer_top_level_connection? && on_master.connection.open_transactions.zero?
+          on_slave { yield }
+        else
+          yield
+        end
+      end
+
+    end
+
+    module InstanceMethods
+      def reload(*args, &block)
+        self.class.on_master do
+          super(*args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/db_charmer/multi_db_migrations.rb

@@ -0,0 +1,29 @@
+module DbCharmer
+  module MultiDbMigrations
+    @@multi_db_name = nil
+
+    def migrate_with_db_wrapper(direction)
+      on_db(@@multi_db_name) { migrate_without_db_wrapper(direction) }
+    end
+
+    def on_db(db_name)
+      announce "Switching connection to #{db_name}"
+      old_proxy = ActiveRecord::Base.db_charmer_connection_proxy
+      ActiveRecord::Base.switch_connection_to(db_name, DbCharmer.migration_connections_should_exist?)
+      yield
+    ensure
+      announce "Checking all database connections"
+      ActiveRecord::Base.verify_active_connections!
+      announce "Switching connection back to default"
+      ActiveRecord::Base.switch_connection_to(old_proxy)
+    end
+
+    def db_magic(opts = {})
+      raise ArgumentError, "No connection name - no magic!" unless opts[:connection]
+      @@multi_db_name = opts[:connection]
+      class << self
+        alias_method_chain :migrate, :db_wrapper
+      end
+    end
+  end
+end

data/lib/db_charmer/multi_db_proxy.rb

@@ -0,0 +1,50 @@
+module DbCharmer
+  module MultiDbProxy
+    class OnDbProxy < BlankSlate
+      def initialize(model_class, slave)
+        @model = model_class
+        @slave = slave
+      end
+
+    private
+
+      def method_missing(meth, *args, &block)
+        @model.on_db(@slave) do |m|
+          m.__send__(meth, *args, &block)
+        end
+      end
+    end
+
+    module ClassMethods
+      def on_db(con, proxy_target = nil)
+        proxy_target ||= self
+        
+        # Chain call
+        return OnDbProxy.new(proxy_target, con) unless block_given?
+
+        # Block call
+        begin
+          self.db_charmer_connection_level += 1
+          old_proxy = db_charmer_connection_proxy
+          switch_connection_to(con, DbCharmer.migration_connections_should_exist?)
+          yield(proxy_target)
+        ensure
+          switch_connection_to(old_proxy)
+          self.db_charmer_connection_level -= 1
+        end
+      end
+    end
+    
+    module MasterSlaveClassMethods
+      def on_slave(con = nil, proxy_target = nil, &block)
+        con ||= db_charmer_random_slave
+        raise ArgumentError, "No slaves found in the class and no slave connection given" unless con
+        on_db(con, proxy_target, &block)
+      end
+
+      def on_master(proxy_target = nil, &block)
+        on_db(nil, proxy_target, &block)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: db-charmer
+version: !ruby/object:Gem::Version 
+  version: 1.3.1
+platform: ruby
+authors: 
+- Alexey Kovyrin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-09 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.0
+    version: 
+description: ActiveRecord Connections Magic (slaves, multiple connections, etc)
+email: alexey@kovyrin.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- Makefile
+- README.rdoc
+- Rakefile
+- VERSION
+- db-charmer.gemspec
+- init.rb
+- lib/db_charmer.rb
+- lib/db_charmer/active_record_extensions.rb
+- lib/db_charmer/association_proxy.rb
+- lib/db_charmer/connection_factory.rb
+- lib/db_charmer/connection_proxy.rb
+- lib/db_charmer/connection_switch.rb
+- lib/db_charmer/db_magic.rb
+- lib/db_charmer/finder_overrides.rb
+- lib/db_charmer/multi_db_migrations.rb
+- lib/db_charmer/multi_db_proxy.rb
+has_rdoc: true
+homepage: http://github.com/kovyrin/db-charmer
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: ActiveRecord Connections Magic
+test_files: []
+