use_db 0.1.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in use_db.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,107 @@
+= UseDb
+
+A multi-database connection scheme for Rails 3, supporting testing and migrations
+
+== Features
+
+=== Easy to use
+1. Bundle the gem
+2. Define a second set of databases in your database.yml file.  Use a prefix to differentiate from the core database.
+3. Add "use_db :prefix => 'your_other_database_prefix_" to the Model
+
+== Supported versions
+
+* Ruby 1.9.2
+
+* Rails 3.0.x
+
+== Install
+
+Put this line in your Gemfile:
+  gem 'use_db'
+
+Then bundle:
+  % bundle
+
+== Usage
+
+=== ACTIVERECORD
+
+Insert a reference to use_db in your model, with a :prefix and/or :suffix
+
+  class MyModel < ActiveRecord::Base
+    use_db :prefix => "your_other_database_prefix_", :suffix => "_is_legacy"
+  end
+
+This maps to a database in database.yml named:
+  your_other_database_prefix_[::Rails.env]_is_legacy
+
+So this is what your database.yml should look like:
+
+  your_other_database_prefix_test_is_legacy
+    adapter: mysql
+    database: other_test_db
+    ...
+  your_other_database_prefix_development_is_legacy
+    adapter: mysql
+    database: other_dev_db
+    ...
+
+You may find it useful (and more DRY) to define an abstract model to inherit from to avoid littering use_db in multiple places:
+
+  class LegacyDataBase < ActiveRecord::Base
+    use_db :prefix => "your_other_database_prefix_", :suffix => "_is_legacy"
+    self.abstract_class = true
+  end
+
+  class MyModel < LegacyDataBase
+  end
+
+=== MIGRATIONS
+
+Each migration intended for a different database needs to be told which to use.  Do this by adding a method "self.database_model" and returning the class name which defines the other database.  If you don't, it defaults to the core database like normal.
+
+class ChangeOtherDatabaseTable < ActiveRecord::Migration
+
+  # For clarity leave me at the top of the class.
+  def self.database_model
+    # Examples depending if you're using an abstract class or not:
+    # return "LegacyDataBase"
+    # return "MyModel"
+  end
+
+end
+
+=== TESTING
+
+In order to test multiple databases, you must invoke a task which clones the development database
+structure and copies it into the test database, clearing out the existing test data.  There is a single
+helper method which executes this task and you invoke it as follows:
+
+UseDbTestSetup.prepare_test_db(:prefix => "your_other_database_prefix_", :suffix => "_is_legacy")
+
+Even though it might not be the best place for it, I put this in my test_helper.
+You don't want it to execute for every test, so put something like this around it:
+
+unless defined?(CLONED_OTHER_DB_FOR_TESTING)
+  UseDbTestSetup.prepare_test_db(:prefix => "your_other_database_prefix_", :suffix => "_is_legacy")
+  CLONED_OTHER_DB_FOR_TESTING = true
+end
+
+=== DEBUGGING
+
+Add this statement in your test_helper or whereever you like such things.
+
+  UseDb.debug_print = true
+
+=== FIXTURES
+
+Nope. I don't use them and you probably shouldn't either, so this gem doesn't support them.  See factory_girl.
+
+== Giving Back
+
+Have a change or improvement?  Fork it, fix it, then send a pull request.
+
+== Credits
+
+David Stevenson (ds@elctech.com) originally wrote the code for this as a plugin for Rails 2. I wanted it to be a gem for Rails 3, so that's what I did. I renamed a few things here and there, added some additional debugging statements, but it's largely what he wrote.  Thanks David.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/migration.rb

@@ -0,0 +1,21 @@
+module ActiveRecord
+  class Migration
+    class << self
+      def method_missing(method, *arguments, &block)
+       say_with_time "#{method}(#{arguments.map { |a| a.inspect }.join(", ")})" do
+         arguments[0] = Migrator.proper_table_name(arguments.first) unless arguments.empty? || method == :execute
+         if (self.respond_to?(:database_model))
+           write "Using custom database model's connection (#{self.database_model}) for this migration"
+           eval("#{self.database_model}.connection.send(method, *arguments, &block)")
+         else
+           ActiveRecord::Base.connection.send(method, *arguments, &block)
+         end
+       end
+     end
+   
+     def uses_db?
+       true
+     end
+   end
+  end
+end

data/lib/test_model.rb

@@ -0,0 +1,10 @@
+def create_test_model(model_name, prefix="", suffix="", rails_env=::Rails.env)
+  # puts "Creating test model '#{model_name}', :prefix => '#{prefix}', :suffix => '#{suffix}'"
+  str = <<-EOF
+    require "use_db"
+    class #{model_name} < ActiveRecord::Base
+      use_db :prefix => "#{prefix}", :suffix => "#{suffix}", :rails_env => "#{rails_env}"
+    end
+EOF
+  eval(str)
+end

data/lib/use_db/version.rb

@@ -0,0 +1,3 @@
+module UseDb
+  VERSION = "0.1.1"
+end

data/lib/use_db.rb

@@ -0,0 +1,63 @@
+module UseDb
+  # Options (recommended to use one or both):
+  #   :prefix - Specify the prefix to append to ::Rails.env when finding the adapter specification in database.yml
+  #   :suffix - Just like :prefix, only concatentated to the end
+  # OR
+  #   :adapter
+  #   :host
+  #   :username
+  #   :password
+  #   ... etc ... same as the options in establish_connection
+
+  @@use_dbs = [ActiveRecord::Base]
+  @@debug_print = false
+
+  def use_db(options)
+    options_dup = options.dup
+    conn_spec = get_use_db_conn_spec(options)
+    puts "Establishing connecting on behalf of #{self.to_s} to #{conn_spec.inspect}" if UseDb.debug_print
+    establish_connection(conn_spec)
+    extend ClassMixin
+    @@use_dbs << self unless @@use_dbs.include?(self) || self.to_s.starts_with?("TestModel")
+  end
+
+  def self.all_use_dbs
+    return @@use_dbs
+  end
+
+  def self.debug_print
+    return @@debug_print
+  end
+
+  def self.debug_print=(newval)
+    @@debug_print = newval
+  end
+
+  module ClassMixin
+    def uses_db?
+      true
+    end
+  end
+
+  def get_use_db_conn_spec(options)
+    options.symbolize_keys
+    puts "get_use_db_conn_spec OPTIONS=#{options.inspect}" if UseDb.debug_print
+    suffix = options.delete(:suffix)
+    prefix = options.delete(:prefix)
+    rails_env = options.delete(:rails_env) || ::Rails.env
+    if (options[:adapter])
+      return options
+    else
+      str = "#{prefix}#{rails_env}#{suffix}"
+      puts "get_use_db_conn_spec STR=#{str.inspect}" if UseDb.debug_print
+      connections = YAML.load(ERB.new(IO.read("#{::Rails.root.to_s}/config/database.yml"), nil, nil, '_use_db_erbout').result)
+      puts "get_use_db_conn_spec CONNECTIONS read. need connections[str]! #{connections.inspect}" if UseDb.debug_print
+      raise "Cannot find database specification.  Configuration '#{str}' expected in config/database.yml" if (connections[str].nil?)
+      return connections[str]
+    end
+  end
+end
+
+ActiveRecord::Base.extend UseDb
+
+require 'use_db_test_setup'

data/lib/use_db_test_setup.rb

@@ -0,0 +1,158 @@
+require "use_db.rb"
+require "test_model.rb"
+
+class UseDbTestSetup
+
+  extend UseDb
+
+  # Used in rake tasks, not normal testing
+  def self.other_databases
+    YAML.load(File.read("#{::Rails.root.to_s}/config/use_db.yml")).values.collect(&:symbolize_keys!)
+  end
+
+  def self.prepare_test_db(options)
+    dump_db_structure(options)
+    purge_db(options)
+    clone_db_structure(options)
+  end
+
+  def self.dump_db_structure(options)
+    options_dup = options.dup
+    options_dup[:rails_env] = "development"
+    conn_spec = get_use_db_conn_spec(options_dup)
+    #establish_connection(conn_spec)
+
+    test_class = setup_test_model(options[:prefix], options[:suffix], "ForDumpStructure")
+
+    puts "Dumping DB structure #{test_class.inspect}..." if UseDb.debug_print
+
+    case conn_spec["adapter"]
+      when "mysql", "oci", "oracle"
+        test_class.establish_connection(conn_spec)
+        File.open("#{::Rails.root.to_s}/db/#{::Rails.env}_structure.sql", "w+") { |f| f << test_class.connection.structure_dump }
+=begin      when "postgresql"
+        ENV['PGHOST']     = abcs[::Rails.env]["host"] if abcs[::Rails.env]["host"]
+        ENV['PGPORT']     = abcs[::Rails.env]["port"].to_s if abcs[::Rails.env]["port"]
+        ENV['PGPASSWORD'] = abcs[::Rails.env]["password"].to_s if abcs[::Rails.env]["password"]
+        search_path = abcs[::Rails.env]["schema_search_path"]
+        search_path = "--schema=#{search_path}" if search_path
+        `pg_dump -i -U "#{abcs[::Rails.env]["username"]}" -s -x -O -f db/#{::Rails.env}_structure.sql #{search_path} #{abcs[::Rails.env]["database"]}`
+        raise "Error dumping database" if $?.exitstatus == 1
+      when "sqlite", "sqlite3"
+        dbfile = abcs[::Rails.env]["database"] || abcs[::Rails.env]["dbfile"]
+        `#{abcs[::Rails.env]["adapter"]} #{dbfile} .schema > db/#{::Rails.env}_structure.sql`
+      when "sqlserver"
+        `scptxfr /s #{abcs[::Rails.env]["host"]} /d #{abcs[::Rails.env]["database"]} /I /f db\\#{::Rails.env}_structure.sql /q /A /r`
+        `scptxfr /s #{abcs[::Rails.env]["host"]} /d #{abcs[::Rails.env]["database"]} /I /F db\ /q /A /r`
+      when "firebird"
+        set_firebird_env(abcs[::Rails.env])
+        db_string = firebird_db_string(abcs[::Rails.env])
+        sh "isql -a #{db_string} > db/#{::Rails.env}_structure.sql"
+=end
+      else
+        raise "Task not supported by '#{conn_spec["adapter"]}'"
+    end
+
+    #if test_class.connection.supports_migrations?
+    #  File.open("db/#{::Rails.env}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+    #end
+
+    test_class.connection.disconnect!
+  end
+
+  def self.clone_db_structure(options)
+    options_dup = options.dup
+    conn_spec = get_use_db_conn_spec(options_dup)
+    #establish_connection(conn_spec)
+
+    test_class = setup_test_model(options[:prefix], options[:suffix], "ForClone")
+
+    puts "Cloning DB structure #{test_class.inspect}..." if UseDb.debug_print
+
+    case conn_spec["adapter"]
+      when "mysql"
+        test_class.connection.execute('SET foreign_key_checks = 0')
+        IO.readlines("#{::Rails.root.to_s}/db/#{::Rails.env}_structure.sql").join.split("\n\n").each do |table|
+          test_class.connection.execute(table)
+        end
+      when "oci", "oracle"
+        IO.readlines("#{::Rails.root.to_s}/db/#{::Rails.env}_structure.sql").join.split(";\n\n").each do |ddl|
+          test_class.connection.execute(ddl)
+        end
+=begin      when "postgresql"
+        ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
+        ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
+        ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
+        `psql -U "#{abcs["test"]["username"]}" -f db/#{::Rails.env}_structure.sql #{abcs["test"]["database"]}`
+      when "sqlite", "sqlite3"
+        dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
+        `#{abcs["test"]["adapter"]} #{dbfile} < db/#{::Rails.env}_structure.sql`
+      when "sqlserver"
+        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{::Rails.env}_structure.sql`
+      when "firebird"
+        set_firebird_env(abcs["test"])
+        db_string = firebird_db_string(abcs["test"])
+        sh "isql -i db/#{::Rails.env}_structure.sql #{db_string}"
+=end
+      else
+        raise "Task not supported by '#{conn_spec["adapter"]}'"
+    end
+
+    test_class.connection.disconnect!
+  end
+
+  def self.purge_db(options)
+    options_dup = options.dup
+    conn_spec = get_use_db_conn_spec(options_dup)
+    #establish_connection(conn_spec)
+
+    test_class = setup_test_model(options[:prefix], options[:suffix], "ForPurge")
+
+    case conn_spec["adapter"]
+      when "mysql"
+        test_class.connection.recreate_database(conn_spec["database"])
+      when "oci", "oracle"
+        test_class.connection.structure_drop.split(";\n\n").each do |ddl|
+          test_class.connection.execute(ddl)
+        end
+      when "firebird"
+        test_class.connection.recreate_database!
+=begin
+      when "postgresql"
+        ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
+        ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
+        ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
+        enc_option = "-E #{abcs["test"]["encoding"]}" if abcs["test"]["encoding"]
+
+        ActiveRecord::Base.clear_active_connections!
+        `dropdb -U "#{abcs["test"]["username"]}" #{abcs["test"]["database"]}`
+        `createdb #{enc_option} -U "#{abcs["test"]["username"]}" #{abcs["test"]["database"]}`
+      when "sqlite","sqlite3"
+        dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
+        File.delete(dbfile) if File.exist?(dbfile)
+      when "sqlserver"
+        dropfkscript = "#{abcs["test"]["host"]}.#{abcs["test"]["database"]}.DP1".gsub(/\\/,'-')
+        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{dropfkscript}`
+        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{::Rails.env}_structure.sql`
+=end
+      else
+        raise "Task not supported by '#{conn_spec["adapter"]}'"
+    end
+
+    test_class.connection.disconnect!
+  end
+
+  def self.setup_test_model(prefix="", suffix="", model_suffix="", rails_env=::Rails.env)
+puts "PREFIX= #{prefix}" if UseDb.debug_print
+puts "SUFFIX= #{suffix}" if UseDb.debug_print
+puts "MODEL SUFFIX= #{model_suffix}" if UseDb.debug_print
+puts "rails_env= #{rails_env}" if UseDb.debug_print
+    prefix ||= ""
+    suffix ||= ""
+    model_name = "TestModel#{prefix.camelize}#{suffix.camelize}#{model_suffix}".gsub("_","").gsub("-","")
+puts "model_name = #{model_name}" if UseDb.debug_print
+    return eval(model_name) if eval("defined?(#{model_name})")
+    create_test_model(model_name, prefix, suffix, rails_env)
+    return eval(model_name)
+  end
+end

data/use_db.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "use_db/version"
+
+Gem::Specification.new do |s|
+  s.name        = "use_db"
+  s.version     = UseDb::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ron Guarisco"]
+  s.email       = ["ron@guarisco.net"]
+  s.homepage    = "https://github.com/guarisco/use_db"
+  s.summary     = %q{Multi-database AR connections for Rails 3}
+  s.description = %q{Multi-database AR connections for Rails 3 models, tests, and migrations.}
+
+  s.rubyforge_project = "use_db"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: use_db
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Ron Guarisco
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-11 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Multi-database AR connections for Rails 3 models, tests, and migrations.
+email: 
+- ron@guarisco.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- lib/migration.rb
+- lib/test_model.rb
+- lib/use_db.rb
+- lib/use_db/version.rb
+- lib/use_db_test_setup.rb
+- use_db.gemspec
+has_rdoc: true
+homepage: https://github.com/guarisco/use_db
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: use_db
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Multi-database AR connections for Rails 3
+test_files: []
+