active_shard 0.1.1 → 0.2.0

data/lib/active_shard/active_record/connection_handler.rb

@@ -1,10 +1,9 @@
+require 'active_record'
 require 'active_record/connection_adapters/abstract/connection_pool'
 
 module ActiveShard
   module ActiveRecord
 
-    autoload :SchemaConnectionPool, 'active_shard/active_record/schema_connection_pool'
-
     class ConnectionHandler < ::ActiveRecord::ConnectionAdapters::ConnectionHandler
 
       # Used to look up shard names
@@ -15,54 +14,110 @@ module ActiveShard
       #
       # @param [Array<ShardDefinition>] shard_definitions
       # @param [Hash] options
-      # @option options [ShardLookupHandler] :shard_lookup
+      # @option options [ShardLookupHandler, #lookup_active_shard] :shard_lookup
       #
-      def initialize( shard_definitions, options={} )
+      def initialize( options={} )
         @shard_lookup = options[ :shard_lookup ]
 
+        @shard_definitions = []
         @connection_pools = {}
         @schema_pools     = {}
+      end
 
-        initialize_shard_definitions( shard_definitions )
+      # @api ShardObserver
+      def add_shards( shard_definitions )
+        shard_definitions.each( &method(:add_shard) )
       end
 
-      def initialize_shard_definitions( definitions )
-        definitions.each do |definition|
-          schema_pools[ definition.schema.to_sym ] ||= SchemaConnectionPool.new(
-              ::ActiveRecord::Base::ConnectionSpecification.new( definition.connection_spec, definition.adapter_method )
-            )
+      # @api ShardObserver
+      def add_shard( shard_definition )
+        connection_pools[ connection_pool_id( shard_definition ) ] = new_connection_pool( shard_definition )
+        shard_definitions << shard_definition
+
+        self
+      end
 
+      # @api ShardObserver
+      def remove_shard( shard_definition )
+        schema_name = shard_definition.schema
 
-          connection_pools[ connection_pool_id( definition.schema, definition.name ) ] =
-            ::ActiveRecord::ConnectionAdapters::ConnectionPool.new(
-              ::ActiveRecord::Base::ConnectionSpecification.new( definition.connection_spec, definition.adapter_method )
-            )
+        # Remove SchemaPool if it's based on this shard
+        #
+        if ( schema_pools[ schema_name ] && schema_pools[ schema_name ].shard_definition == shard_definition )
+          schema_pools[ schema_name ].disconnect!
+          schema_pools.delete( schema_name )
         end
+
+        pool_id = connection_pool_id( shard_definition )
+
+        # Remove connection pool
+        connection_pools[ pool_id ].disconnect!
+        connection_pools.delete( pool_id )
+
+        shard_definitions.delete( shard_definition )
+
+        self
+      end
+
+      # @api ShardObserver
+      def remove_all_shards!
+        defs = shard_definitions.dup
+
+        defs.each( &method(:remove_shard) )
       end
 
+      # I want to put this in here, but it seems to cause problems that I haven't yet tracked down. [BLS]
+      #
       #def establish_connection( *args )
       #  raise NoMethodError, "Sharded models do not support establish_connection"
       #end
 
       # Retrieve connection pool for class
       #
+      # @param [#schema_name] klass An object which responds to #schema_name
+      # @return [ConnectionPool,SchemaConnectionPool] connection pool
+      #
       def retrieve_connection_pool( klass )
-        schema_name = klass.schema_name
+        schema_name = ( sn = klass.schema_name ).nil? ? nil : sn.to_sym
 
         active_shard_name = shard_lookup.lookup_active_shard( schema_name )
-
-        Rails.logger.debug( "RetrieveConnectionPool for #{klass.name}, schema_name #{schema_name}, active_shard #{active_shard_name}")
         
         ( active_shard_name.nil? ?
-            schema_pools[ schema_name.to_sym ] :
+            get_schema_pool_for( schema_name ) :
             connection_pools[ connection_pool_id( schema_name, active_shard_name ) ] )
       end
 
       private
 
         attr_reader :schema_pools
+        attr_reader :shard_definitions
+
+        def get_schema_pool_for( schema_name )
+          schema_name = schema_name.nil? ? nil : schema_name.to_sym
+          
+          schema_pools[ schema_name ] ||= new_schema_pool( shard_definitions_for_schema( schema_name ).first )
+        end
+
+        def new_schema_pool( definition )
+          ConnectionProxyPool.new( definition, :proxy_class => SchemaConnectionProxy )
+        end
+
+        def new_connection_pool( definition )
+          ConnectionProxyPool.new( definition )
+        end
+
+        def shard_definitions_for_schema( schema_name )
+          shard_definitions.find_all { |sd| sd.belongs_to_schema?( schema_name ) }
+        end
+
+        # args are either a ShardDefinition or a schema and shard name.
+        #
+        def connection_pool_id( *args )
+          definition = args.first.is_a?( ShardDefinition ) ? args.shift : nil
+
+          schema_name = definition.nil? ? args.shift : definition.schema
+          shard_name  = definition.nil? ? args.shift : definition.name
 
-        def connection_pool_id( schema_name, shard_name )
           "#{schema_name.to_s}+#{shard_name.to_s}".to_sym
         end
 

data/lib/active_shard/active_record/connection_proxy_pool.rb

@@ -0,0 +1,37 @@
+require 'active_record'
+require 'active_record/connection_adapters/abstract/connection_pool'
+
+require 'active_shard/active_record/connection_specification_adapter'
+
+module ActiveShard
+  module ActiveRecord
+
+    # ConnectionPool designed to return connection proxies of configurable types
+    #
+    class ConnectionProxyPool < ::ActiveRecord::ConnectionAdapters::ConnectionPool
+
+      attr_reader :shard_definition
+
+      # @param [ShardDefinition] definition
+      # @param [Hash] options
+      # @option options [Class] :proxy_class
+      #
+      def initialize( definition, options={} )
+        super( ConnectionSpecificationAdapter.new( definition ) )
+
+        @shard_definition = definition
+        @proxy_class = options[:proxy_class]
+      end
+
+      private
+
+        attr_reader :proxy_class
+
+        def new_connection
+          proxy_class.nil? ? super : proxy_class.new( super )
+        end
+
+    end
+
+  end
+end

data/lib/active_shard/active_record/connection_specification_adapter.rb

@@ -0,0 +1,27 @@
+module ActiveShard
+  module ActiveRecord
+
+    class ConnectionSpecificationAdapter
+
+      # @param [ShardDefinition] shard_definition
+      #
+      def initialize( shard_definition )
+        @shard_definition = shard_definition
+      end
+
+      def adapter_method
+        "#{shard_definition.connection_spec[:adapter]}_connection"
+      end
+
+      def config
+        shard_definition.connection_spec
+      end
+
+      private
+
+        attr_reader :shard_definition
+
+    end
+
+  end
+end

data/lib/active_shard/active_record/schema_connection_proxy.rb

@@ -0,0 +1,36 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_shard/exceptions'
+
+module ActiveShard
+  module ActiveRecord
+
+    # SchemaConnectionProxy holds a Connection object and restricts messages passed
+    # to it. Only schema-ish messages are allowed.
+    #
+    class SchemaConnectionProxy
+
+      delegate :columns,
+               :verify,
+               :verify!,
+               :run_callbacks,
+               :_run_checkin_callbacks,
+               :quote_table_name,
+               :quote_value,
+               :disconnect!,
+               :quote, :to => :target
+
+      def initialize( target )
+        @target = target
+      end
+
+      def method_missing( sym, *args, &block )
+        raise ::ActiveShard::NoActiveShardError
+      end
+
+      private
+        def target
+          @target
+        end
+    end
+  end
+end

data/lib/active_shard/active_record.rb

@@ -1,3 +1,5 @@
+require 'active_record'
+
 module ActiveShard
 
   # The ActiveShard::ActiveRecord module contains the code necessary for ActiveRecord
@@ -6,10 +8,16 @@ module ActiveShard
   # -- Need to add explanation of ShardedBase VS ShardSupport --
   #
   module ActiveRecord
-    
-    autoload :ConnectionHandler,    'active_shard/active_record/connection_handler'
-    autoload :ShardSupport,         'active_shard/active_record/shard_support'
-    autoload :ShardedBase,          'active_shard/active_record/sharded_base'
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :ConnectionHandler
+      autoload :ConnectionProxyPool
+      autoload :ConnectionSpecificationAdapter
+      autoload :SchemaConnectionProxy
+      autoload :ShardSupport
+      autoload :ShardedBase
+    end
 
   end
 end

data/lib/active_shard/config.rb

@@ -1,50 +1,46 @@
+require 'active_shard/shard_collection'
+
 module ActiveShard
-  autoload :ShardDefinition,    'active_shard/shard_definition'
-  autoload :ShardCollection,    'active_shard/shard_collection'
 
   class Config
 
-    # Returns a filtered list of shards that belong to
-    # the specified schema
-    #
-    # @return [Array] shards belonging to schema
-    #
-    def shards_by_schema( schema_name )
-      shard_collection.by_schema( schema_name )
+    def shard_configuration=( configuration )
+      shard_collections.clear
+      
+      configuration.each_pair do |environment, shard_definitions|
+        shard_collection( environment.to_sym ).add_shards( shard_definitions )
+      end
     end
 
-    # Returns the name of a shard usable for schema definition
-    # connections
-    #
-    def schema_shard_name_by_schema( schema_name )
-      shard_def = shard_definitions_by_schema( schema_name ).first
-
-      shard_def.nil? ? nil : shard_def.name.to_sym
+    def shards_by_schema( environment, schema )
+      shard_collection( environment ).by_schema( schema )
     end
 
-    # Returns a Shard Definition by the shard name
-    #
-    # @return [ShardDefinition]
-    #
-    def shard( name )
-      shard_collection.shard( name )
+    def add_shard( environment, shard_definition )
+      shard_collection( environment ).add_shard( shard_definition )
     end
 
-    def add_shard( *args )
-      shard_collection.add_shard( *args )
+    def shard_definitions( environment )
+      shard_collection( environment )
     end
 
-    def shard_definitions
-      shard_collection.shard_definitions
+    def remove_shard( environment, shard_name )
+      shard_collection( environment ).remove_shard( shard_name )
     end
 
-    def remove_shard( shard_name )
-      shard_collection.remove_shard( shard_name )
+    def shard( environment, shard_name )
+      shard_collection( environment ).shard( shard_name )
     end
 
     private
-      def shard_collection
-        @shard_collection ||= ShardCollection.new
+      def shard_collection( enviro )
+        enviro = enviro.nil? ? nil : enviro.to_sym
+        
+        shard_collections[ enviro ] ||= ShardCollection.new
+      end
+
+      def shard_collections
+        @shard_collections ||= {}
       end
 
   end

data/lib/active_shard/exceptions.rb

@@ -6,11 +6,12 @@ module ActiveShard
   # than nesting.
   #
 
+  # Base exception for all ActiveShard errors
+  #
   class ActiveShardError < StandardError; end
 
     class DefinitionError < ActiveShardError; end
       class NameNotUniqueError < DefinitionError; end
-
     class NoActiveShardError < ActiveShardError; end
 
 end

data/lib/active_shard/railtie.rb

@@ -0,0 +1,64 @@
+require "active_shard"
+
+module ActiveShard
+  class Railtie < Rails::Railtie
+
+    config.active_shard = ActiveSupport::OrderedOptions.new
+
+    rake_tasks do
+      load "active_shard/rails/database.rake"
+    end
+
+    initializer "active_shard.logger" do
+      ActiveSupport.on_load(:active_shard) { self.logger ||= ::Rails.logger }
+    end
+
+    initializer "active_shard.set_configs" do |app|
+      ActiveSupport.on_load(:active_shard) do
+        app.config.active_shard.each do |k,v|
+          send "#{k}=", v
+        end
+      end
+    end
+
+    initializer "active_shard.initialize_framework" do |app|
+      ActiveSupport.on_load(:active_shard) do
+
+        # TODO: Should anyone build code to plug ActiveShard into other ORMs, this
+        # Railtie could support that by respecting a configuration option.
+        #
+        # something like 'active_shard/data_mapper', 'active_shard/sequel'
+        #
+        require "active_shard/active_record"
+
+        ::ActiveRecord::Base.send( :include, ActiveShard::ActiveRecord::ShardSupport )
+        ::ActiveRecord::Base.schema_name( self.base_schema_name ) if self.base_schema_name
+
+        handler =
+          ActiveShard::ActiveRecord::ConnectionHandler.new(
+             :shard_lookup => ActiveShard::ShardLookupHandler.new( :scope => ActiveShard.scope )
+           )
+
+        self.shard_observers << handler
+
+        ::ActiveRecord::Base.connection_handler = handler
+      end
+    end
+
+    initializer "active_shard.initialize_shard_configuration" do |app|
+      ActiveSupport.on_load(:active_shard) do
+        unless app.config.active_shard.shard_configuration
+          self.shard_configuration =
+            ActiveShard::ShardDefinition.from_yaml_file( Rails.root.join( "config", "shards.yml" ) )
+        end
+      end
+    end
+
+    initializer "active_shard.set_environment" do |app|
+      ActiveSupport.on_load(:active_shard) do
+        ActiveShard.environment = Rails.env.to_s
+      end
+    end
+
+  end
+end

data/lib/active_shard/scope.rb

@@ -52,6 +52,9 @@ module ActiveShard
 
     # Remove the last scope from the stack
     #
+    # FIXME: Symbols (for AnySchema) may not roll back properly if multiple
+    #        the same symbol is on the stack several times
+    #
     def pop( pop_until=nil )
       if pop_until.nil?
         scope_crumbs.pop

data/lib/active_shard/scope_manager.rb

@@ -17,7 +17,7 @@ module ActiveShard
     #   scope instances
     #
     def initialize( options={} )
-      @scope_class = options[:scope_class] if options[:scope_class]
+      self.scope_class = options[:scope_class] if options[:scope_class]
     end
 
     # @see ActiveShard::Scope#push

data/lib/active_shard/shard_collection.rb

@@ -11,6 +11,7 @@ module ActiveShard
   # in most situations.
   #
   class ShardCollection
+    include Enumerable
 
     # Initializes a shard group
     #
@@ -84,6 +85,10 @@ module ActiveShard
       self.class.new( definitions_by_schema( schema_name ) )
     end
 
+    def schemas
+      definitions.map { |d| d.schema }.uniq.compact
+    end
+
     # Removes a shard definition from the collection based on the
     # provided shard name.
     #
@@ -118,6 +123,18 @@ module ActiveShard
     def any_shard
       definitions[ rand( definitions.size ) ].name
     end
+    
+    def each( &block )
+      definitions.each( &block )
+    end
+
+    def length
+      definitions.length
+    end
+
+    def size
+      length
+    end
 
     private
 

data/lib/active_shard/shard_definition.rb

@@ -1,9 +1,10 @@
+require 'active_support/hash_with_indifferent_access'
+
 module ActiveShard
 
   class ShardDefinition
     attr_accessor :schema
     attr_accessor :name
-    attr_writer :connection_spec
 
     class << self
 
@@ -15,9 +16,31 @@ module ActiveShard
       # @return [Hash] hash of environments and lists of Definitions
       #
       def from_yaml_file( file_name )
-        definitions = {}
+        from_yaml( File.open( file_name ).read() )
+      end
 
-        hash = YAML.load( ERB.new( File.open( file_name ).read() ).result )
+      # Returns a hash with environments as the hash keys and
+      # a list of ShardDefinitions as the hash values
+      #
+      # @param [String] yaml YAML string to parse
+      #
+      # @return [Hash] hash of environments and lists of Definitions
+      #
+      def from_yaml( yaml )
+        hash = YAML.load( ERB.new( yaml ).result )
+
+        from_hash( hash )
+      end
+
+      # Returns a hash with environments as the hash keys and
+      # a list of ShardDefinitions as the hash values
+      #
+      # @param [Hash] hash raw hash in YAML-format
+      #
+      # @return [Hash] hash of environments and lists of Definitions
+      #
+      def from_hash( hash )
+        definitions = {}
 
         hash.each_pair do |environment, schemas|
           schemas.each_pair do |schema, shards|
@@ -44,13 +67,21 @@ module ActiveShard
     def initialize( name, options={} )
       opts = options.dup
 
-      @name             = name
-      @schema           = opts.delete( :schema )
-      @connection_spec  = symbolize_keys( opts )
+      @name                 = name.to_sym
+      @schema               = ( ( sch = opts.delete( :schema ) ).nil? ? nil : sch.to_sym )
+      self.connection_spec  = opts
     end
 
-    def adapter_method
-      "#{connection_spec[:adapter]}_connection"
+    def connection_adapter
+      @connection_adapter ||= connection_spec[:adapter]
+    end
+    
+    def connection_database
+      @connection_database ||= connection_spec[:database]
+    end
+
+    def connection_spec=(val)
+      @connection_spec = val.nil? ? nil : HashWithIndifferentAccess.new( val )
     end
 
     def connection_spec
@@ -70,6 +101,16 @@ module ActiveShard
       ( schema.to_sym == schema_name.to_sym )
     end
 
+    def ==( other )
+      eql?( other )
+    end
+
+    def eql?( other )
+      (self.name == other.name) &&
+        (self.schema == other.schema) &&
+        (self.connection_spec == other.connection_spec)
+    end
+
     private
 
       def symbolize_keys( hash )

data/lib/active_shard/shard_lookup_handler.rb

@@ -1,28 +1,26 @@
 module ActiveShard
 
-  # Handles current and schema shard resolution using the current
-  # scope and
+  # Handles current shard resolution using the provided scope
+  #
   class ShardLookupHandler
 
     # Initializes a shard lookup handler
     #
     # @param [Hash] options
     # @option options [Scope,ScopeManager] :scope
-    # @option options [Config] :config
-    #   scope instances
     #
     def initialize( options={} )
       @scope  = options[:scope]
-      @config = options[:config]
     end
 
+    # Returns the active shard for the provided schema, or nil if none.
+    #
+    # @param [Symbol] schema_name
+    # @return [Symbol, nil] shard name if any
+    #
     def lookup_active_shard( schema_name )
       @scope.active_shard_for_schema( schema_name )
     end
 
-    def lookup_schema_shard( schema_name )
-      @config.schema_shard_name_by_schema( schema_name )
-    end
-
   end
 end

data/lib/active_shard/version.rb

@@ -1,3 +1,3 @@
 module ActiveShard
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/lib/active_shard.rb

@@ -1,19 +1,45 @@
+require 'active_support'
+
 module ActiveShard
+  extend ActiveSupport::Autoload
 
-  autoload :Config,               'active_shard/config'
-  autoload :ScopeManager,         'active_shard/scope_manager'
-  autoload :ShardLookupHandler,   'active_shard/shard_lookup_handler'
-  autoload :ShardCollection,      'active_shard/shard_collection'
+  autoload :Config
+  autoload :Scope
+  autoload :ScopeManager
+  autoload :ShardCollection
+  autoload :ShardDefinition
+  autoload :ShardLookupHandler
 
   class << self
 
+    def with_environment( val )
+      previous_environment = self.environment
+      self.environment = val
+
+      yield
+
+      self.environment = previous_environment
+    end
+
+    def environment=( val )
+      env_changed = !( @environment.to_s == val.to_s )
+
+      @environment = val.nil? ? nil : val.to_sym
+
+      reload_observer_shards! if env_changed
+    end
+
+    def environment
+      @environment
+    end
+
     # Returns the current Config object for ActiveShard.
     #
     # @yield [c] yields the current config object to the block for setup
     #
     # @return [Config] current config
     #
-    def config()
+    def config
       @config ||= Config.new
 
       yield( @config ) if block_given?
@@ -21,6 +47,68 @@ module ActiveShard
       @config
     end
 
+    def base_schema_name=(val)
+      @base_schema_name = val.nil? ? nil : val.to_sym
+    end
+
+    def base_schema_name
+      @base_schema_name
+    end
+
+    def shard_configuration=( configuration )
+      config.shard_configuration=( configuration )
+
+      reload_observer_shards!
+    end
+
+    # Doesn't yet support anything other than ActiveRecord::Base
+    #
+    #def base_class=(val)
+    #  @base_class = val
+    #end
+    #
+    #def base_class
+    #  @base_class
+    #end
+
+    def notify_shard_observers( message, *args )
+      shard_observers.each do |observer|
+        observer.public_send( message, *args ) if observer.respond_to?( message )
+      end
+    end
+
+    def add_shard_observer( observer )
+      shard_observers << observer
+    end
+
+    def shard_observers
+      @shard_observers ||= []
+    end
+
+    def add_shard( *args )
+      definition = args.first.is_a?( ShardDefinition ) ? args.first : ShardDefinition.new( *args )
+
+      config.add_shard( environment, definition )
+
+      notify_shard_observers( :add_shard, definition )
+
+      definition
+    end
+
+    def remove_shard( shard_name )
+      config.remove_shard( environment, shard_name )
+
+      notify_shard_observers( :remove_shard, shard_name )
+    end
+
+    def shard_definitions
+      config.shard_definitions( environment )
+    end
+
+    def shard( shard_name )
+      config.shard( environment, shard_name )
+    end
+
     # Sets the current scope handling object.
     #
     # Scope handler must respond to the following methods:
@@ -92,6 +180,11 @@ module ActiveShard
       @logger = val
     end
 
+    def reload_observer_shards!
+      notify_shard_observers( :remove_all_shards! )
+      notify_shard_observers( :add_shards, shard_definitions )
+    end
+
   end
 end
 

metadata

@@ -2,7 +2,7 @@
 name: active_shard
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - Brasten Sager
@@ -11,9 +11,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-15 00:00:00 Z
-dependencies: []
-
+date: 2011-08-19 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
 description: ActiveShard is a library that implements flexible sharding in ActiveRecord and Rails.
 email: 
 - brasten@dashwire.com
@@ -25,17 +35,17 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- CHANGELOG
 - README.md
 - lib/active_shard/active_record/connection_handler.rb
-- lib/active_shard/active_record/railtie.rb
-- lib/active_shard/active_record/schema_connection_adapter.rb
-- lib/active_shard/active_record/schema_connection_pool.rb
+- lib/active_shard/active_record/connection_proxy_pool.rb
+- lib/active_shard/active_record/connection_specification_adapter.rb
+- lib/active_shard/active_record/schema_connection_proxy.rb
 - lib/active_shard/active_record/shard_support.rb
 - lib/active_shard/active_record/sharded_base.rb
 - lib/active_shard/active_record.rb
 - lib/active_shard/config.rb
 - lib/active_shard/exceptions.rb
+- lib/active_shard/railtie.rb
 - lib/active_shard/scope.rb
 - lib/active_shard/scope_manager.rb
 - lib/active_shard/shard_collection.rb
@@ -43,7 +53,7 @@ files:
 - lib/active_shard/shard_lookup_handler.rb
 - lib/active_shard/version.rb
 - lib/active_shard.rb
-homepage: 
+homepage: https://github.com/dashwire/active_shard
 licenses: []
 
 post_install_message: 

data/CHANGELOG

@@ -1,11 +0,0 @@
-## 0.1.1 ##
-- bug in Railtie prevented gem from working
-
-## 0.1.0 ##
-
-- initial release of code and gem
-- includes working code base, missing completed railtie, better specs.
-
-## 0.0.1 ##
-
-- stub gem while setting up git repo, etc.

data/lib/active_shard/active_record/railtie.rb

@@ -1,56 +0,0 @@
-require "active_shard"
-require "rails"
-
-module ActiveShard
-  module ActiveRecord
-    class Railtie < Rails::Railtie
-
-      config.active_shard = ActiveSupport::OrderedOptions.new
-
-      rake_tasks do
-        load "active_shard/active_record/rails/database.rake"
-      end
-
-      initializer "active_shard.logger" do
-        ActiveSupport.on_load(:active_shard) { self.logger ||= ::Rails.logger }
-      end
-
-      initializer "active_shard.set_configs" do |app|
-        ActiveSupport.on_load(:active_record) do
-          app.config.active_record.each do |k,v|
-            send "#{k}=", v
-          end
-        end
-      end
-
-      initializer "active_shard.initialize_database" do |app|
-        ActiveSupport.on_load(:active_record) do
-          self.configurations = app.config.database_configuration
-          establish_connection
-        end
-      end
-
-  # ActiveShard.config do |c|
-  #   definitions = ActiveShard::ShardDefinition.from_yaml_file( File.expand_path( '../shards.yml', __FILE__ ) )
-  # 
-  #   definitions[ Rails.env.to_sym ].each do |shard|
-  #     c.add_shard( shard )
-  #   end
-  # end
-  # 
-  # require 'active_shard/active_record'
-  # 
-  # ActiveRecord::Base.send( :include, ActiveShard::ActiveRecord::ShardSupport )
-  # 
-  # ActiveRecord::Base.connection_handler =
-  #   ActiveShard::ActiveRecord::ConnectionHandler.new(
-  #     ActiveShard.config.shard_definitions,
-  #     :shard_lookup => ActiveShard::ShardLookupHandler.new( :scope => ActiveShard.scope, :config => ActiveShard.config )
-  #   )
-  # 
-  # ActiveRecord::Base.schema_name( :main )
-
-
-    end
-  end
-end

data/lib/active_shard/active_record/schema_connection_adapter.rb

@@ -1,23 +0,0 @@
-require 'active_shard/exceptions'
-
-module ActiveShard
-  module ActiveRecord
-    class SchemaConnectionAdapter
-
-      delegate :columns, :verify, :verify!, :run_callbacks, :quote_table_name, :quote_value, :quote, :to => :adapter
-
-      def initialize( adapter )
-        @adapter = adapter
-      end
-
-      def method_missing( sym, *args, &block )
-        raise ::ActiveShard::NoActiveShardError
-      end
-
-      private
-        def adapter
-          @adapter
-        end
-    end
-  end
-end

data/lib/active_shard/active_record/schema_connection_pool.rb

@@ -1,18 +0,0 @@
-require 'active_record/connection_adapters/abstract/connection_pool'
-
-module ActiveShard
-  module ActiveRecord
-
-    autoload :SchemaConnectionAdapter, 'active_shard/active_record/schema_connection_adapter'
-
-    class SchemaConnectionPool < ::ActiveRecord::ConnectionAdapters::ConnectionPool
-
-      private
-        def new_connection
-          SchemaConnectionAdapter.new( super )
-        end
-
-    end
-
-  end
-end