connection_manager 1.0.4 → 1.1.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: connection_manager
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.0
 platform: ruby
 authors:
 - Joshua Mckinney
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-28 00:00:00.000000000 Z
+date: 2014-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -31,19 +31,53 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '4.1'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - <=
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - <=
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: thread_safe
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: autotest
   requirement: !ruby/object:Gem::Requirement
@@ -87,27 +121,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: mysql2
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
-    - - <=
-      - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
-    - - <=
-      - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: mysql2
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
@@ -120,8 +148,8 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Simplifies connecting to Multiple and Replication databases with rails
-  and active_record
+description: Improves support for cross-schema, replication and mutli-DMS applications
+  using ActiveRecord.
 email:
 - joshmckin@gmail.com
 executables: []
@@ -137,29 +165,36 @@ files:
 - Rakefile
 - connection_manager.gemspec
 - lib/connection_manager.rb
-- lib/connection_manager/connection_builder.rb
-- lib/connection_manager/connection_manager_railtie.rb
-- lib/connection_manager/helpers/abstract_adapter_helper.rb
-- lib/connection_manager/helpers/connection_helpers.rb
-- lib/connection_manager/patches/cross_schema_patch.rb
+- lib/connection_manager/builder.rb
+- lib/connection_manager/connection_adapters/abstract_adapter.rb
+- lib/connection_manager/connection_adapters/mysql_adapter.rb
+- lib/connection_manager/connection_handling.rb
+- lib/connection_manager/core.rb
+- lib/connection_manager/querying.rb
+- lib/connection_manager/railtie.rb
+- lib/connection_manager/relation.rb
 - lib/connection_manager/replication.rb
 - lib/connection_manager/shards.rb
 - lib/connection_manager/using.rb
 - lib/connection_manager/version.rb
+- spec/database.yml
 - spec/factories.rb
 - spec/helpers/database_spec_helper.rb
 - spec/helpers/models_spec_helper.rb
-- spec/jdbcmysql_database.yml
-- spec/lib/connection_builder_spec.rb
-- spec/lib/connection_helpers_spec.rb
-- spec/lib/patches/cross_schema_path_spec.rb
+- spec/lib/builder_spec.rb
+- spec/lib/connection_adapters/abstract_adapter_spec.rb
+- spec/lib/connection_adapters/mysql_adapter_spec.rb
+- spec/lib/connection_handling_spec.rb
+- spec/lib/core_spec.rb
+- spec/lib/integration/cross_schema_spec.rb
+- spec/lib/querying_spec.rb
+- spec/lib/relation_spec.rb
 - spec/lib/replication_spec.rb
 - spec/lib/shards_spec.rb
+- spec/lib/using_proxy_spec.rb
 - spec/lib/using_spec.rb
-- spec/mysql2_database.yml
 - spec/spec.opts
 - spec/spec_helper.rb
-- spec/sqlite_database.yml
 homepage: ''
 licenses: []
 metadata: {}
@@ -182,20 +217,23 @@ rubyforge_project: connection_manager
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Simplifies connecting to Multiple and Replication databases with rails and
-  active_record
+summary: Cross-schema, replication and mutli-DMS gem for ActiveRecord.
 test_files:
+- spec/database.yml
 - spec/factories.rb
 - spec/helpers/database_spec_helper.rb
 - spec/helpers/models_spec_helper.rb
-- spec/jdbcmysql_database.yml
-- spec/lib/connection_builder_spec.rb
-- spec/lib/connection_helpers_spec.rb
-- spec/lib/patches/cross_schema_path_spec.rb
+- spec/lib/builder_spec.rb
+- spec/lib/connection_adapters/abstract_adapter_spec.rb
+- spec/lib/connection_adapters/mysql_adapter_spec.rb
+- spec/lib/connection_handling_spec.rb
+- spec/lib/core_spec.rb
+- spec/lib/integration/cross_schema_spec.rb
+- spec/lib/querying_spec.rb
+- spec/lib/relation_spec.rb
 - spec/lib/replication_spec.rb
 - spec/lib/shards_spec.rb
+- spec/lib/using_proxy_spec.rb
 - spec/lib/using_spec.rb
-- spec/mysql2_database.yml
 - spec/spec.opts
 - spec/spec_helper.rb
-- spec/sqlite_database.yml

data/lib/connection_manager/connection_builder.rb

@@ -1,82 +0,0 @@
-require 'active_support/core_ext/hash/indifferent_access'
-module ConnectionManager
-  module ConnectionBuilder         
-      
-    # Get the current environment if defined
-    # Check for Rails, check for RACK_ENV, default to 'development'
-    def ar_env
-      return Rails.env if defined?(Rails)
-      return RACK_ENV if defined?(RACK_ENV)
-      return ENV["AR_ENV"] if ENV["AR_ENV"]
-      "development"
-    end
-    
-    # Grab only those connections that correspond to the current env. If env
-    # is blank it grabs all the connection keys
-    # 
-    # If you current environment valid database keys can be:
-    # * development
-    # * other_database_development
-    # * slave_database_development  
-    def configuration_keys
-      ActiveRecord::Base.configurations.keys.select{|n| n.match(ar_env_regex)}
-    end
-      
-    def database_yml_attributes(name_from_yml)
-      found = ActiveRecord::Base.configurations[name_from_yml]
-      ActiveRecord::Base.configurations[name_from_yml].symbolize_keys if found
-    end
-        
-    # Returns currently loaded configurations where :build_connection is true
-    def database_keys_for_auto_build
-      ab_configs = []
-      configuration_keys.each do |key|    
-        ab_configs << key if (database_yml_attributes(key)[:build_connection_class] == true)
-      end
-      ab_configs
-    end
-    
-    # Builds connection classes using the database keys provided; expects an array.
-    def build_connection_classes(database_keys_to_use=database_keys_for_auto_build)      
-      database_keys_to_use.each do |key|
-        build_connection_class(connection_class_name(key),key) 
-      end
-    end 
-    
-    # Build connection classes base on the supplied class name and connection 
-    # key from database.yml
-    def build_connection_class(class_name,connection_key)
-      begin
-        class_name.constantize
-      rescue NameError 
-        klass = Class.new(ActiveRecord::Base)
-        new_connection_class = Object.const_set(class_name, klass)  
-        new_connection_class.establish_managed_connection(connection_key)
-        new_connection_class.use_database(new_connection_class.current_database_name)
-      end
-    end
-    
-    private
-    def ar_env_regex
-      return @ar_env_regex if @ar_env_regex
-      s = "#{ar_env}$"
-      @ar_env_regex = Regexp.new("(#{s})")
-    end
-      
-    # Creates a string to be used for the class name. Removes the current env.
-    def clean_yml_key(name)
-      new_name = "#{name}".gsub(ar_env_regex,'')      
-      new_name = "Base"if new_name.blank?
-      new_name.gsub(/\_$/,'')
-    end
-      
-    # Given an connection key name from the database.yml, returns the string 
-    # equivalent of the class name for that entry.
-    def connection_class_name(name_from_yml)
-      new_class_name = clean_yml_key(name_from_yml)
-      new_class_name = new_class_name.gsub(/\_/,' ').titleize.gsub(/ /,'')
-      new_class_name << "Connection"
-      new_class_name
-    end
-  end
-end

data/lib/connection_manager/connection_manager_railtie.rb

@@ -1,8 +0,0 @@
-module ConnectionManager
-  class ConnectionManagerRailtie < ::Rails::Railtie
-    initializer "connection_manager.build_connection_classes" do
-      ActiveRecord::Base.build_connection_classes
-    end
-  end
-end
-

data/lib/connection_manager/helpers/abstract_adapter_helper.rb

@@ -1,95 +0,0 @@
-module ConnectionManager
-  module AbstractAdapterHelper
-    def config
-      @config
-    end
-
-    # Determines if connection supports cross database queries
-    def cross_database_support?
-      @cross_database_support ||= (@config[:cross_database_support] || @config[:adapter].match(/(mysql)|(postgres)|(sqlserver)/i))
-    end
-    alias :cross_schema_support? :cross_database_support?
-
-    def using_em_adapter?
-      (@config[:adapter].match(/^em\_/) && defined?(EM) && EM::reactor_running?)
-    end
-
-    def readonly?
-      (@config[:readonly] == true)
-    end
-
-    def replicated?
-      (!slave_keys.blank? || !master_keys.blank?)
-    end
-
-    def database_name
-      @config[:database]
-    end
-
-    def replication_keys(type=:slaves)
-      return slave_keys if type == :slaves
-      master_keys
-    end
-
-    def slave_keys
-       @slave_keys ||= (@config[:slaves] ? @config[:slaves].collect{|r| r.to_sym} : [] )
-    end
-
-    def master_keys
-      @master_keys ||= (@config[:masters] ? @config[:masters].collect{|r| r.to_sym} : [])
-    end
-
-    if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR <= 1
-
-      # Returns the schema for a give table. Returns nil of multiple matches are found  
-      def fetch_table_schema(table_name)
-        return nil unless cross_database_support?
-        sql = "SELECT table_schema FROM INFORMATION_SCHEMA.TABLES WHERE table_name = '#{table_name}'"
-        results = execute(sql, 'SCHEMA')
-        found = results.to_a
-        return found[0][0] if (found.length == 1)
-        nil
-      end
-
-      # Returns table_schema.table_name for the given table. Returns nil if multiple matches are found
-      def fetch_full_table_name(table_name)
-        return nil unless cross_database_support?
-        return table_name if (table_name.to_s.match(/(^$)|(\.)/))
-        sql = "SELECT CONCAT(table_schema,'.',table_name) FROM INFORMATION_SCHEMA.TABLES WHERE table_name = '#{table_name}'"
-        found = nil
-        results = execute(sql, 'SCHEMA')
-        found = results.to_a
-        if (found.length == 1)
-          found = found[0][0]
-        else
-          found = table_name
-        end
-        found
-      end
-    else
-      
-      # Returns the schema for a give table. Returns nil of multiple matches are found      
-      def fetch_table_schema(table_name)
-        return nil unless cross_database_support?
-        sql = "SELECT table_schema FROM INFORMATION_SCHEMA.TABLES WHERE table_name = '#{table_name}'"
-        execute_and_free(sql, 'SCHEMA') do |result|
-          found = result.to_a
-          return nil unless (found.length == 1)
-          found[0][0]
-        end
-      end
-
-      # Returns table_schema.table_name for the given table. Returns nil if multiple matches are found
-      def fetch_full_table_name(table_name)
-        return nil unless cross_database_support?
-        return table_name if (table_name.to_s.match(/(^$)|(\.)/))
-        sql = "SELECT CONCAT(table_schema,'.',table_name) FROM INFORMATION_SCHEMA.TABLES WHERE table_name = '#{table_name}'"
-        execute_and_free(sql, 'SCHEMA') do |result|
-          found = result.to_a
-          return table_name unless (found.length == 1)
-          found[0][0]
-        end
-      end
-    end
-  end
-end

data/lib/connection_manager/helpers/connection_helpers.rb

@@ -1,119 +0,0 @@
-require 'active_support/core_ext/hash/indifferent_access'
-module ConnectionManager
-  module ConnectionHelpers       
-    @@managed_connections = HashWithIndifferentAccess.new
-    
-    # Returns the database_name of the connection unless set otherwise
-    def current_database_name
-      return "#{connection.config[:database].to_s}" if @current_database_name.blank?
-      @current_database_name
-    end
-    alias :database_name :current_database_name
-    alias :current_schema_name :current_database_name
-    alias :schema_name :current_database_name
-    
-    
-    # Sometimes we need to manually set the database name, like when the connection
-    # has a database but our table is in a different database/schema but on the
-    # same DMS.
-    def current_database_name=current_database_name
-      @current_database_name= current_database_name
-    end
-    alias :database_name= :current_database_name=
-    alias :current_schema_name= :current_database_name=
-    alias :schema_name= :current_database_name=
-    
-    # Returns true if this is a readonly only a readonly model
-    # If the connection.readonly? then the model that uses the connection 
-    # must be readonly.
-    def readonly?
-      ((@readonly == true)||connection.readonly?)
-    end
-    
-    # Allow setting of readonly at the model level
-    def readonly=readonly
-      @readonly = readonly
-    end
-    
-    # A place to store managed connections
-    def managed_connections
-      @@managed_connections
-    end
-    
-    def add_managed_connections(yml_key,value)
-      @@managed_connections[yml_key] ||= []
-      @@managed_connections[yml_key] << value unless @@managed_connections[yml_key].include?(value)
-      @@managed_connections
-    end
-    
-    def managed_connection_classes
-      managed_connections.values.flatten
-    end
-    
-    def yml_key
-      @yml_key
-    end
-    
-    # Tell Active Record to use a different database/schema on this model.
-    # You may call #use_database when your schemas reside on the same database server
-    # and you do not want to create extra connection class and database.yml entries.
-    # 
-    # Options:
-    # * :table_name_prefix - the prefix required for making cross database/schema
-    # joins for you database management system. By default table_name_prefix is the
-    # database/schema name followed by a period EX: "my_database."
-    # * :table_name - the table name for the model if it does not match ActiveRecord
-    # naming conventions
-    # 
-    # EX: class LegacyUser < ActiveRecord::Base
-    #       use_database('DBUser', :table_name => 'UserData')
-    #     end
-    #     
-    #     LegacyUser.limit(1).to_sql => "SELECT * FROM `BDUser`.`UserData` LIMIT 1
-    #
-    def use_database(database_name=nil,opts={})
-      self.current_database_name = database_name if database_name
-      opts[:table_name_prefix] = "#{self.current_database_name}." if opts[:table_name_prefix].blank? && self.connection.cross_database_support?
-      unless self.abstract_class? || self.name == "ActiveRecord::Base"
-        opts[:table_name] = self.table_name if opts[:table_name].blank?
-        opts[:table_name].gsub!(self.table_name_prefix,'') unless self.table_name_prefix.blank?
-        self.table_name = "#{opts[:table_name_prefix]}#{opts[:table_name]}"
-      end
-      self.table_name_prefix = opts[:table_name_prefix] unless opts[:table_name_prefix].blank?
-    end
-    alias :use_schema :use_database
-   
-    # Establishes and checks in a connection, normally for abstract classes AKA connection classes.
-    # 
-    # Options:
-    # * :abstract_class - used the set #abstract_class, default is true
-    # * :readonly - force all instances to readonly
-    # * :class_name - name of connection class name, default is current class name
-    # * :table_name_prefix - prefix to append to table name for cross database joins,
-    #     default is the "#{self.database_name}."
-    # EX:
-    #   class MyConnection < ActiveRecord::Base
-    #     establish_managed_connection :key_from_db_yml,{:readonly => true}
-    #   end
-    #
-    def establish_managed_connection(yml_key,opts={})
-      @yml_key = yml_key
-      opts = {:class_name => self.name, 
-        :abstract_class => true}.merge(opts)   
-      establish_connection(yml_key)     
-      self.abstract_class = opts[:abstract_class]
-      set_to_readonly if (readonly? || opts[:readonly] || self.connection.readonly?)
-      add_managed_connections(yml_key,opts[:class_name])
-      use_database(self.current_database_name,opts)
-    end
-          
-    # Override ActiveRecord::Base instance method readonly? to force 
-    # readonly connections.
-    def set_to_readonly
-      self.readonly = true
-      define_method(:readonly?) do 
-        true
-      end  
-    end
-  end
-end

data/lib/connection_manager/patches/cross_schema_patch.rb

@@ -1,67 +0,0 @@
-module ActiveRecord
-  class Base
-    class << self
-      # We want to make sure we get the full table name with schema
-      def arel_table # :nodoc:
-        begin
-          @arel_table ||= Arel::Table.new(quoted_table_name.to_s.gsub('`',''), arel_engine)
-        rescue ActiveRecord::ConnectionNotEstablished
-          Arel::Table.new(table_name, arel_engine)
-        end
-      end
-
-      private
-      
-      # In a schema schema environment we want to set table name prefix
-      # to the schema_name + . if its not set already
-      alias :base_compute_table_name :compute_table_name
-      def compute_table_name
-        result = base_compute_table_name
-        if result.match(/^[^.]*$/) && connection.cross_schema_support?
-          t_schema = connection.fetch_table_schema(undecorated_table_name(name))
-          self.table_name_prefix = "#{t_schema}." if t_schema
-          result = base_compute_table_name
-        end
-        result
-      end
-    end
-  end
-end
-
-if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR <= 1
-  require 'active_record/connection_adapters/mysql2_adapter'
-  module ActiveRecord
-    module ConnectionAdapters
-      class Mysql2Adapter < AbstractAdapter
-
-        # Force all tables to be cached for the life connection
-        def cached_tables
-          @cached_tables ||= {}
-        end
-
-        def tables(name = nil, database = nil, like =nil)
-          return cached_tables[database] if cached_tables[database] && like.nil?
-          cached_tables[database] ||= []
-          return [like] if like && cached_tables[database].include?(like)
-          sql = "SHOW TABLES "
-          sql << "IN #{database} " if database
-          sql << "LIKE #{quote(like)}" if like
-          result = execute(sql, 'SCHEMA')
-          cached_tables[database] = (cached_tables[database] | result.collect { |field| field[0] }).compact
-        end
-
-        # We have to clean the name of '`' and fetch table name with schema
-        def table_exists?(name)
-          return false unless name
-          name          = name.to_s
-          schema, table = name.split('.', 2)
-          unless table # A table was provided without a schema
-            table  = schema
-            schema = nil
-          end
-          tables(nil, schema, table).include?(table)
-        end
-      end
-    end
-  end
-end

data/spec/jdbcmysql_database.yml

@@ -1,50 +0,0 @@
-# Warning: The database defined as "test" will be erased and
-# re-generated from your development database when you run "rake".
-# Do not set this db to the same as development or production.
-common: &common
-  adapter: jdbcmysql
-  username: root
-  password: omegared
-  pool: 100
-  timeout: 5000
-  build_connection_class: true
-  
-master: &master
-  username: root
-  password: omegared
-  
-readonly: &readonly
-  username: readonly
-  password: omegared
-  
-test:
-  <<: *common
-  <<: *master
-  database: cm_test
-  slaves: [slave_1_cm_test, slave_2_cm_test]
-  
-cm_user_test:
-  <<: *common
-  <<: *master
-  database: cm_user_test
-  slaves: [slave_1_cm_user_test]
-  
-slave_1_cm_test:
-  <<: *common 
-  <<: *readonly
-  database: cm_test
-  
-slave_2_cm_test:
-  <<: *common
-  <<: *readonly
-  database: cm_test
-  
-shard_1_cm_test:  
-   <<: *common
-   <<: *master
-   database: legacy_cm_test
-
-slave_1_cm_user_test:
-  <<: *common
-  <<: *readonly
-  database: cm_user_test

data/spec/lib/connection_builder_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-describe ConnectionManager::ConnectionBuilder do
-
-  describe '#connection_class_name' do 
-    it "should return a string for a class name appended with 'Connection' " do
-      ActiveRecord::Base.send(:connection_class_name,"my_database").should eql("MyDatabaseConnection")
-    end
-    it "should return remove the appended rails env" do
-      ActiveRecord::Base.send(:connection_class_name,"my_database_test").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
-      ActiveRecord::Base.send(:connection_class_name,"test").should eql("BaseConnection")
-    end
-  end
-    
-  describe '#build_connection_class' do
-    before(:all) do
-      ActiveRecord::Base.build_connection_class("MyConnectionClass", :test)
-    end
-    it "should add a class with supplied class name to ConnectionManager::ConnectionBuilder" do
-      defined?(MyConnectionClass).should be_true
-      MyConnectionClass.is_a?(Class).should be_true
-    end
-    it "should have a super class of ActiveRecord::Base" do
-      MyConnectionClass.superclass.should eql(ActiveRecord::Base)
-    end
-  end   
-end