db-charmer 1.7.0.pre6 → 1.7.0.pre7

data/CHANGES

@@ -1,5 +1,7 @@
 1.7.0 (not released yet):
 
+Beta feature: Rails 3 support
+
 Beta feature: Added force_slave_reads functionality. Now we could have models with slaves
 that are not used by default, but could be turned on globally (per-controller or per-action).
 

data/README.rdoc

@@ -560,26 +560,36 @@ return an array of sharding connection names or connection configurations to be
 establish shard connections in a loop.
 
 
-== Documentation
+== Documentation/Questions
 
 For more information on the plugin internals, please check out the source code. All the plugin's
-code is ~100% covered with a tests that were placed in a separate staging rails project located
+code is ~100% 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.
 
+If you have any questions regarding this project, you could contact the author using
+the DbCharmer Users Group mailing list:
+
+- Group Info: http://groups.google.com/group/db-charmer
+- Subscribe using the info page or by sending an email to db-charmer-subscribe@googlegroups.com
+
 
 == What Ruby and Rails implementations does it work for?
 
-We have a continuous integration setups for this plugin on MRI 1.8.7 with Rails 2.2 and 2.3.
-We use the plugin in production on Scribd.com with MRI (rubyee) 1.8.7 and Rails 2.2, Rails 2.3,
-Sinatra and plain Rack applications.
+We have a continuous integration setups for this plugin on MRI 1.8.7 with Rails 2.2, 2.3 and 3.0.
+We use the plugin in production on Scribd.com with MRI (Ruby Enterprise Edition) 1.8.7 and
+Rails 2.2, Rails 2.3, Sinatra and plain Rack applications.
+
+Starting with version 1.7.0 we support Rails 3.0, but until further notice we consider it a 
+beta-quality feature since we do not run any production software on this version of Rails. If you
+run your application on Rails 3.0, please contact the author.
 
 
 == 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. Most of 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.
+other people to use. Most of the code in this package has been developed by Oleksiy Kovyrin for
+Scribd.com and is released under the MIT license. For more details, see the LICENSE file.
 
 Other contributors who have helped with the development of this library are (alphabetically ordered):
 * Allen Madsen

data/db-charmer.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.version       = DbCharmer::Version::STRING
   s.platform      = Gem::Platform::RUBY
 
-  s.authors       = [ 'Alexey Kovyrin' ]
+  s.authors       = [ 'Oleksiy Kovyrin' ]
   s.email         = 'alexey@kovyrin.net'
   s.homepage      = 'http://github.com/kovyrin/db-charmer'
   s.summary       = 'ActiveRecord Connections Magic (slaves, multiple connections, etc)'
@@ -15,16 +15,15 @@ Gem::Specification.new do |s|
 
   s.rdoc_options = [ '--charset=UTF-8' ]
 
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'yard'
-  s.add_development_dependency 'actionpack'
-
   s.files            = `git ls-files`.split("\n")
   s.require_paths    = [ 'lib' ]
   s.extra_rdoc_files = [ 'LICENSE', 'README.rdoc' ]
 
   # Dependencies
-  s.add_dependency 'activesupport', '~> 2.2'
-  s.add_dependency 'activerecord', '~> 2.2'
-end
+  s.add_dependency 'activesupport', '< 3.1'
+  s.add_dependency 'activerecord', '< 3.1'
 
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'actionpack'
+end

data/lib/db_charmer.rb

@@ -1,3 +1,6 @@
+# In Rails 2.2 they did not add it to the autoload so it won't work w/o this require
+require 'active_record/version' unless defined?(::ActiveRecord::VERSION::MAJOR)
+
 module DbCharmer
   # Configure autoload
   autoload :Sharding, 'db_charmer/sharding'
@@ -6,6 +9,16 @@ module DbCharmer
     autoload :ForceSlaveReads, 'db_charmer/action_controller/force_slave_reads'
   end
 
+  # Used in all Rails3-specific places
+  def self.rails3?
+    ::ActiveRecord::VERSION::MAJOR > 2
+  end
+
+  # Used in all Rails2-specific places
+  def self.rails2?
+    ::ActiveRecord::VERSION::MAJOR == 2
+  end
+
   # Accessors
   @@connections_should_exist = true
   mattr_accessor :connections_should_exist
@@ -62,7 +75,8 @@ private
     old_hijack_new_classes = @@hijack_new_classes
     begin
       @@hijack_new_classes = true
-      ::ActiveRecord::Base.send(:subclasses).each do |subclass|
+      subclasses_method = DbCharmer.rails3? ? :descendants : :subclasses
+      ::ActiveRecord::Base.send(subclasses_method).each do |subclass|
         subclass.hijack_connection!
       end
       yield
@@ -87,9 +101,16 @@ ActiveRecord::Base.extend(DbCharmer::ActiveRecord::ClassAttributes)
 require 'db_charmer/active_record/connection_switching'
 ActiveRecord::Base.extend(DbCharmer::ActiveRecord::ConnectionSwitching)
 
-# Enable misc AR extensions
-require 'db_charmer/abstract_adapter/log_formatting'
-ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, DbCharmer::AbstractAdapter::LogFormatting)
+# Enable AR logging extensions
+if DbCharmer.rails3?
+  require 'db_charmer/rails3/abstract_adapter/connection_name'
+  require 'db_charmer/rails3/active_record/log_subscriber'
+  ActiveRecord::LogSubscriber.send(:include, DbCharmer::ActiveRecord::LogSubscriber)
+  ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, DbCharmer::AbstractAdapter::ConnectionName)
+else
+  require 'db_charmer/rails2/abstract_adapter/log_formatting'
+  ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, DbCharmer::AbstractAdapter::LogFormatting)
+end
 
 # Enable connection proxy in AR
 require 'db_charmer/active_record/multi_db_proxy'
@@ -97,9 +118,19 @@ ActiveRecord::Base.extend(DbCharmer::ActiveRecord::MultiDbProxy::ClassMethods)
 ActiveRecord::Base.extend(DbCharmer::ActiveRecord::MultiDbProxy::MasterSlaveClassMethods)
 ActiveRecord::Base.send(:include, DbCharmer::ActiveRecord::MultiDbProxy::InstanceMethods)
 
-# Enable connection proxy for scopes
-require 'db_charmer/active_record/named_scope/scope_proxy'
-ActiveRecord::NamedScope::Scope.send(:include, DbCharmer::ActiveRecord::NamedScope::ScopeProxy)
+# Enable connection proxy for relations
+if DbCharmer.rails3?
+  require 'db_charmer/rails3/active_record/relation_method'
+  require 'db_charmer/rails3/active_record/relation/connection_routing'
+  ActiveRecord::Base.extend(DbCharmer::ActiveRecord::RelationMethod)
+  ActiveRecord::Relation.send(:include, DbCharmer::ActiveRecord::Relation::ConnectionRouting)
+end
+
+# Enable connection proxy for scopes (rails 2.x only)
+if DbCharmer.rails2?
+  require 'db_charmer/rails2/active_record/named_scope/scope_proxy'
+  ActiveRecord::NamedScope::Scope.send(:include, DbCharmer::ActiveRecord::NamedScope::ScopeProxy)
+end
 
 # Enable connection proxy for associations
 # WARNING: Inject methods to association class right here (they proxy include calls somewhere else, so include does not work)
@@ -131,7 +162,12 @@ require 'db_charmer/active_record/migration/multi_db_migrations'
 ActiveRecord::Migration.extend(DbCharmer::ActiveRecord::Migration::MultiDbMigrations)
 
 # Enable the magic
-require 'db_charmer/active_record/finder_overrides'
+if DbCharmer.rails3?
+  require 'db_charmer/rails3/active_record/master_slave_routing'
+else
+  require 'db_charmer/rails2/active_record/master_slave_routing'
+end
+
 require 'db_charmer/active_record/sharding'
 require 'db_charmer/active_record/db_magic'
 ActiveRecord::Base.extend(DbCharmer::ActiveRecord::DbMagic)

data/lib/db_charmer/action_controller/force_slave_reads.rb

@@ -35,8 +35,10 @@ module DbCharmer
       end
 
       module InstanceMethods
+        DISPATCH_METHOD = (DbCharmer.rails3?) ? :process_action : :perform_action
+
         def self.included(base)
-          base.alias_method_chain :perform_action, :forced_slave_reads
+          base.alias_method_chain DISPATCH_METHOD, :forced_slave_reads
         end
 
         def force_slave_reads!
@@ -53,11 +55,13 @@ module DbCharmer
 
       protected
 
-        def perform_action_with_forced_slave_reads
-          DbCharmer.with_controller(self) do
-            perform_action_without_forced_slave_reads
+        class_eval <<-EOF
+          def #{DISPATCH_METHOD}_with_forced_slave_reads(*args, &block)
+            DbCharmer.with_controller(self) do
+              #{DISPATCH_METHOD}_without_forced_slave_reads(*args, &block)
+            end
           end
-        end
+        EOF
       end
 
     end

data/lib/db_charmer/active_record/connection_switching.rb

@@ -29,6 +29,7 @@ module DbCharmer
       def hijack_connection!
         return if self.respond_to?(:connection_with_magic)
         class << self
+          # Make sure we check our accessors before going to the default connection retrieval method
           def connection_with_magic
             db_charmer_remapped_connection || db_charmer_connection_proxy || connection_without_magic
           end
@@ -62,8 +63,8 @@ module DbCharmer
       end
 
       #-----------------------------------------------------------------------------------------------------------------
-      def switch_connection_to(conn, require_config_to_exist = true)
-        new_conn = coerce_to_connection_proxy(conn, require_config_to_exist)
+      def switch_connection_to(conn, should_exist = true)
+        new_conn = coerce_to_connection_proxy(conn, should_exist)
 
         if db_charmer_connection_proxy.is_a?(DbCharmer::Sharding::StubConnection)
           db_charmer_connection_proxy.set_real_connection(new_conn)
@@ -71,7 +72,10 @@ module DbCharmer
 
         self.db_charmer_connection_proxy = new_conn
         self.hijack_connection!
+
+        # self.reset_column_information
       end
+
     end
   end
 end

data/lib/db_charmer/active_record/db_magic.rb

@@ -21,7 +21,7 @@ module DbCharmer
         forced_slave_reads = opt.has_key?(:force_slave_reads) ? opt[:force_slave_reads] : true
 
         # Setup all the slaves related magic if needed
-        setup_slaves_magic(opt[:slaves], forced_slave_reads, should_exist) if opt[:slaves].any?
+        setup_slaves_magic(opt[:slaves], forced_slave_reads, should_exist)
 
         # Setup inheritance magic
         setup_children_magic(opt)
@@ -63,15 +63,20 @@ module DbCharmer
       end
 
       def setup_slaves_magic(slaves, force_slave_reads, should_exist = true)
+        self.db_charmer_force_slave_reads = force_slave_reads
+
+        # Initialize the slave connections list
         self.db_charmer_slaves = slaves.collect do |slave|
           coerce_to_connection_proxy(slave, should_exist)
         end
+        return if db_charmer_slaves.empty?
 
-        self.db_charmer_force_slave_reads = force_slave_reads
-
-        self.extend(DbCharmer::ActiveRecord::FinderOverrides::ClassMethods)
-        self.send(:include, DbCharmer::ActiveRecord::FinderOverrides::InstanceMethods)
+        # Enable on_slave/on_master methods
         self.extend(DbCharmer::ActiveRecord::MultiDbProxy::MasterSlaveClassMethods)
+
+        # Enable automatic master/slave queries routing (we have specialized versions on those modules for rails2/3)
+        self.extend(DbCharmer::ActiveRecord::MasterSlaveRouting::ClassMethods)
+        self.send(:include, DbCharmer::ActiveRecord::MasterSlaveRouting::InstanceMethods)
       end
 
     end

data/lib/db_charmer/active_record/multi_db_proxy.rb

@@ -62,6 +62,15 @@ module DbCharmer
         def on_master(proxy_target = nil, &block)
           on_db(db_charmer_default_connection, proxy_target, &block)
         end
+
+        def first_level_on_slave
+          first_level = db_charmer_top_level_connection? && on_master.connection.open_transactions.zero?
+          if first_level && db_charmer_force_slave_reads? && db_charmer_slaves.any?
+            on_slave { yield }
+          else
+            yield
+          end
+        end
       end
     end
   end

data/lib/db_charmer/connection_proxy.rb

@@ -4,6 +4,9 @@ module DbCharmer
     # We need to do this because in Rails 2.3 BasicObject does not remove object_id method, which is stupid
     undef_method(:object_id) if instance_methods.member?('object_id')
 
+    # We use this to get a connection class from the proxy
+    attr_accessor :abstract_connection_class
+
     def initialize(abstract_class, db_name)
       @abstract_connection_class = abstract_class
       @db_name = db_name

data/lib/db_charmer/{abstract_adapter → rails2/abstract_adapter}/log_formatting.rb

@@ -11,6 +11,7 @@ module DbCharmer
         @config[:connection_name]
       end
 
+      # Rails 2.X specific logging method
       def format_log_entry_with_connection_name(message, dump = nil)
         msg = connection_name ? "[#{connection_name}] " : ''
         msg = "  \e[0;34;1m#{msg}\e[0m" if connection_name && ::ActiveRecord::Base.colorize_logging

data/lib/db_charmer/{active_record/finder_overrides.rb → rails2/active_record/master_slave_routing.rb}

@@ -1,6 +1,6 @@
 module DbCharmer
   module ActiveRecord
-    module FinderOverrides
+    module MasterSlaveRouting
 
       module ClassMethods
         SLAVE_METHODS = [ :find_by_sql, :count_by_sql, :calculate ]
@@ -34,18 +34,6 @@ module DbCharmer
             super(*args, &block)
           end
         end
-
-      private
-
-        def first_level_on_slave
-          first_level = db_charmer_top_level_connection? && on_master.connection.open_transactions.zero?
-          if first_level && db_charmer_force_slave_reads?
-            on_slave { yield }
-          else
-            yield
-          end
-        end
-
       end
 
       module InstanceMethods

data/lib/db_charmer/rails3/abstract_adapter/connection_name.rb

@@ -0,0 +1,38 @@
+module DbCharmer
+  module AbstractAdapter
+    module ConnectionName
+
+      # We use this proxy to push connection name down to instrumenters w/o monkey-patching the log method itself
+      class InstrumenterDecorator < ActiveSupport::BasicObject
+        def initialize(adapter, instrumenter)
+          @adapter = adapter
+          @instrumenter = instrumenter
+        end
+
+        def instrument(name, payload = {}, &block)
+          payload[:connection_name] ||= @adapter.connection_name
+          @instrumenter.instrument(name, payload, &block)
+        end
+
+        def method_missing(meth, *args, &block)
+          @instrumenter.send(meth, *args, &block)
+        end
+      end
+
+      def self.included(base)
+        base.alias_method_chain :initialize, :connection_name
+      end
+
+      def connection_name
+        raise "Can't find connection configuration!" unless @config
+        @config[:connection_name]
+      end
+
+      def initialize_with_connection_name(*args)
+        initialize_without_connection_name(*args)
+        @instrumenter = InstrumenterDecorator.new(self, @instrumenter)
+      end
+
+    end
+  end
+end

data/lib/db_charmer/rails3/active_record/log_subscriber.rb

@@ -0,0 +1,23 @@
+module DbCharmer
+  module ActiveRecord
+    module LogSubscriber
+
+      def self.included(base)
+        base.send(:attr_accessor, :connection_name)
+        base.alias_method_chain :sql, :connection_name
+        base.alias_method_chain :debug, :connection_name
+      end
+
+      def sql_with_connection_name(event)
+        self.connection_name = event.payload[:connection_name]
+        sql_without_connection_name(event)
+      end
+
+      def debug_with_connection_name(msg)
+        conn = connection_name ? color("  [#{connection_name}]", ActiveSupport::LogSubscriber::BLUE, true) : ''
+        debug_without_connection_name(conn + msg)
+      end
+
+    end
+  end
+end

data/lib/db_charmer/rails3/active_record/master_slave_routing.rb

@@ -0,0 +1,46 @@
+module DbCharmer
+  module ActiveRecord
+    module MasterSlaveRouting
+
+      module ClassMethods
+        SLAVE_METHODS = [ :find_by_sql, :count_by_sql ]
+        MASTER_METHODS = [ ] # I don't know any methods in AR::Base that change data directly w/o going to the relation object
+
+        SLAVE_METHODS.each do |slave_method|
+          class_eval <<-EOF, __FILE__, __LINE__ + 1
+            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, __FILE__, __LINE__ + 1
+            def #{master_method}(*args, &block)
+              on_master do
+                super(*args, &block)
+              end
+            end
+          EOF
+        end
+      end
+
+      module InstanceMethods
+        MASTER_METHODS = [ :reload ]
+
+        MASTER_METHODS.each do |master_method|
+          class_eval <<-EOF, __FILE__, __LINE__ + 1
+            def #{master_method}(*args, &block)
+              self.class.on_master do
+                super(*args, &block)
+              end
+            end
+          EOF
+        end
+      end
+
+    end
+  end
+end

data/lib/db_charmer/rails3/active_record/relation/connection_routing.rb

@@ -0,0 +1,147 @@
+module DbCharmer
+  module ActiveRecord
+    module Relation
+      module ConnectionRouting
+
+        # All the methods that could be querying the database
+        SLAVE_METHODS = [ :calculate, :exists? ]
+        MASTER_METHODS = [ :delete, :delete_all, :destroy, :destroy_all, :reload, :update, :update_all ]
+        ALL_METHODS = SLAVE_METHODS + MASTER_METHODS
+
+        DB_CHARMER_ATTRIBUTES = [ :db_charmer_connection, :db_charmer_connection_is_forced, :db_charmer_enable_slaves ]
+
+        # Define the default relation connection + override all the query methods here
+        def self.included(base)
+          init_attributes(base)
+          init_routing(base)
+        end
+
+        # Define our attributes + spawn methods shit needs to be changed to make sure our accessors are copied over to the new instances
+        def self.init_attributes(base)
+          DB_CHARMER_ATTRIBUTES.each do |attr|
+            base.send(:attr_accessor, attr)
+          end
+
+          # Override spawn methods
+          base.alias_method_chain :except, :db_charmer
+          base.alias_method_chain :only, :db_charmer
+        end
+
+        # Override all query methods
+        def self.init_routing(base)
+          ALL_METHODS.each do |meth|
+            base.alias_method_chain meth, :db_charmer
+          end
+
+          # Special case: for normal selects we go to the slave, but for selects with a lock we should use master
+          base.alias_method_chain :to_a, :db_charmer
+        end
+
+        # Copy db_charmer attributes in addition to what they're copying
+        def except_with_db_charmer(*args)
+          except_without_db_charmer(*args).tap do |result|
+            copy_db_charmer_options(self, result)
+          end
+        end
+
+        # Copy db_charmer attributes in addition to what they're copying
+        def only_with_db_charmer(*args)
+          only_without_db_charmer(*args).tap do |result|
+            copy_db_charmer_options(self, result)
+          end
+        end
+
+        # Copy our accessors from one instance to another
+        def copy_db_charmer_options(src, dst)
+          DB_CHARMER_ATTRIBUTES.each do |attr|
+            dst.send("#{attr}=".to_sym, src.send(attr))
+          end
+        end
+
+        # Connection switching (changes the default relation connection)
+        def on_db(con, &block)
+          if block_given?
+            @klass.on_db(con, &block)
+          else
+            clone.tap do |result|
+              result.db_charmer_connection = con
+              result.db_charmer_connection_is_forced = true
+            end
+          end
+        end
+
+        # Make sure we get the right connection here
+        def connection
+          @klass.on_db(db_charmer_connection).connection
+        end
+
+        # Selects preferred destination (master/slave/default) for a query
+        def select_destination(method, recommendation = :default)
+          # If this relation was created within a forced connection block (e.g Model.on_db(:foo).relation)
+          # Then we should use that connection everywhere except cases when a model is slave-enabled
+          # in those cases DML queries go to the master
+          if db_charmer_connection_is_forced
+            return :master if db_charmer_enable_slaves && MASTER_METHODS.member?(method)
+            return :default
+          end
+
+          # If this relation is created from a slave-enabled model, let's do the routing if possible
+          if db_charmer_enable_slaves
+            return :slave if SLAVE_METHODS.member?(method)
+            return :master if MASTER_METHODS.member?(method)
+          else
+            # Make sure we do not use recommended destination
+            recommendation = :default
+          end
+
+          # If nothing else came up, let's use the default or recommended connection
+          return recommendation
+        end
+
+        # Switch the model to default relation connection
+        def switch_connection_for_method(method, recommendation = nil)
+          # Choose where to send the query
+          destination ||= select_destination(method, recommendation)
+
+          # What method to use
+          on_db_method = [ :on_db, db_charmer_connection ]
+          on_db_method = :on_master if destination == :master
+          on_db_method = :first_level_on_slave if destination == :slave
+
+          # Perform the query
+          @klass.send(*on_db_method) do
+            yield
+          end
+        end
+
+        # For normal selects we go to the slave, but for selects with a lock we should use master
+        def to_a_with_db_charmer(*args, &block)
+          preferred_destination = :slave
+          preferred_destination = :master if lock_value
+
+          switch_connection_for_method(:to_a, preferred_destination) do
+            to_a_without_db_charmer(*args, &block)
+          end
+        end
+
+        # Need this to mimick alias_method_chain name generation (exists? => exists_with_db_charmer?)
+        def self.aliased_method_name(target, with)
+          aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+          "#{aliased_target}_#{with}_db_charmer#{punctuation}"
+        end
+
+        # Override all the query methods here
+        ALL_METHODS.each do |method|
+          class_eval <<-EOF, __FILE__, __LINE__ + 1
+            def #{aliased_method_name method, :with}(*args, &block)
+              switch_connection_for_method(:#{method.to_s}) do
+                #{aliased_method_name method, :without}(*args, &block)
+              end
+            end
+          EOF
+        end
+
+      end
+    end
+  end
+end

data/lib/db_charmer/rails3/active_record/relation_method.rb

@@ -0,0 +1,28 @@
+module DbCharmer
+  module ActiveRecord
+    module RelationMethod
+
+      def self.extended(base)
+        class << base
+          alias_method_chain :relation, :db_charmer
+          alias_method_chain :arel_engine, :db_charmer
+        end
+      end
+
+      # Create a relation object and initialize its default connection
+      def relation_with_db_charmer(*args, &block)
+        relation_without_db_charmer(*args, &block).tap do |rel|
+          rel.db_charmer_connection = self.connection
+          rel.db_charmer_enable_slaves = self.db_charmer_slaves.any?
+          rel.db_charmer_connection_is_forced = !db_charmer_top_level_connection?
+        end
+      end
+
+      # Use the model itself an engine for Arel, do not fall back to AR::Base
+      def arel_engine_with_db_charmer(*)
+        self
+      end
+
+    end
+  end
+end

data/lib/db_charmer/sharding/stub_connection.rb

@@ -18,6 +18,10 @@ module DbCharmer
         @real_conn = real_conn
       end
 
+      def db_charmer_connection_name
+        "StubConnection"
+      end
+
       def real_connection
         # Return memoized real connection
         return @real_conn if @real_conn
@@ -44,6 +48,10 @@ module DbCharmer
           raise ::ActiveRecord::ConnectionNotEstablished, "No real connection to proxy this method to!"
         end
 
+        if real_connection.kind_of?(DbCharmer::Sharding::StubConnection)
+          raise ::ActiveRecord::ConnectionNotEstablished, "You have to switch connection on your model before using it!"
+        end
+
         # Proxy the call to our real connection target
         real_connection.__send__(meth, *args, &block)
       end

data/lib/db_charmer/version.rb

@@ -3,7 +3,7 @@ module DbCharmer
     MAJOR = 1
     MINOR = 7
     PATCH = 0
-    BUILD = 'pre6'
+    BUILD = 'pre7'
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
   end

metadata

@@ -1,55 +1,56 @@
 --- !ruby/object:Gem::Specification 
 name: db-charmer
 version: !ruby/object:Gem::Version 
-  hash: 1923832053
+  hash: 1923832055
   prerelease: 6
   segments: 
   - 1
   - 7
   - 0
   - pre
-  - 6
-  version: 1.7.0.pre6
+  - 7
+  version: 1.7.0.pre7
 platform: ruby
 authors: 
-- Alexey Kovyrin
+- Oleksiy Kovyrin
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-06-27 00:00:00 -04:00
-default_executable: 
+date: 2011-08-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: activesupport
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - <
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 5
         segments: 
-        - 0
-        version: "0"
-  type: :development
+        - 3
+        - 1
+        version: "3.1"
+  type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: yard
+  name: activerecord
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - <
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 5
         segments: 
-        - 0
-        version: "0"
-  type: :development
+        - 3
+        - 1
+        version: "3.1"
+  type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: actionpack
+  name: rspec
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
@@ -63,34 +64,32 @@ dependencies:
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: activesupport
+  name: yard
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 3
         segments: 
-        - 2
-        - 2
-        version: "2.2"
-  type: :runtime
+        - 0
+        version: "0"
+  type: :development
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: activerecord
+  name: actionpack
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 3
         segments: 
-        - 2
-        - 2
-        version: "2.2"
-  type: :runtime
+        - 0
+        version: "0"
+  type: :development
   version_requirements: *id005
 description: DbCharmer is a Rails plugin (and gem) that could be used to manage AR model connections, implement master/slave query schemes, sharding and other magic features many high-scale applications need.
 email: alexey@kovyrin.net
@@ -111,21 +110,26 @@ files:
 - db-charmer.gemspec
 - init.rb
 - lib/db_charmer.rb
-- lib/db_charmer/abstract_adapter/log_formatting.rb
 - lib/db_charmer/action_controller/force_slave_reads.rb
 - lib/db_charmer/active_record/association_preload.rb
 - lib/db_charmer/active_record/class_attributes.rb
 - lib/db_charmer/active_record/connection_switching.rb
 - lib/db_charmer/active_record/db_magic.rb
-- lib/db_charmer/active_record/finder_overrides.rb
 - lib/db_charmer/active_record/migration/multi_db_migrations.rb
 - lib/db_charmer/active_record/multi_db_proxy.rb
-- lib/db_charmer/active_record/named_scope/scope_proxy.rb
 - lib/db_charmer/active_record/sharding.rb
 - lib/db_charmer/connection_factory.rb
 - lib/db_charmer/connection_proxy.rb
 - lib/db_charmer/core_extensions.rb
 - lib/db_charmer/force_slave_reads.rb
+- lib/db_charmer/rails2/abstract_adapter/log_formatting.rb
+- lib/db_charmer/rails2/active_record/master_slave_routing.rb
+- lib/db_charmer/rails2/active_record/named_scope/scope_proxy.rb
+- lib/db_charmer/rails3/abstract_adapter/connection_name.rb
+- lib/db_charmer/rails3/active_record/log_subscriber.rb
+- lib/db_charmer/rails3/active_record/master_slave_routing.rb
+- lib/db_charmer/rails3/active_record/relation/connection_routing.rb
+- lib/db_charmer/rails3/active_record/relation_method.rb
 - lib/db_charmer/sharding.rb
 - lib/db_charmer/sharding/connection.rb
 - lib/db_charmer/sharding/method.rb
@@ -136,7 +140,6 @@ files:
 - lib/db_charmer/sharding/stub_connection.rb
 - lib/db_charmer/version.rb
 - lib/tasks/databases.rake
-has_rdoc: true
 homepage: http://github.com/kovyrin/db-charmer
 licenses: []
 
@@ -168,7 +171,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.8
 signing_key: 
 specification_version: 3
 summary: ActiveRecord Connections Magic (slaves, multiple connections, etc)