fourthbase 2.1.2

data/lib/fourth_base/base.rb

@@ -0,0 +1,8 @@
+module FourthBase
+  class Base < ActiveRecord::Base
+
+    self.abstract_class = true
+    establish_connection FourthBase.config
+
+  end
+end

data/lib/fourth_base/databases.rake

@@ -0,0 +1,121 @@
+namespace :db do
+  namespace :fourth_base do
+
+    namespace :create do
+      task :all do
+        FourthBase.on_base { Rake::Task['db:create:all'].execute }
+      end
+    end
+
+    task :create do
+      FourthBase.on_base { Rake::Task['db:create'].execute }
+    end
+
+    namespace :drop do
+      task :all do
+        FourthBase.on_base { Rake::Task['db:drop:all'].execute }
+      end
+    end
+
+    namespace :purge do
+      task :all do
+        FourthBase.on_base { Rake::Task['db:purge:all'].execute }
+      end
+    end
+
+    task :purge do
+      FourthBase.on_base { Rake::Task['db:purge'].execute }
+    end
+
+    task :migrate do
+      FourthBase.on_base { Rake::Task['db:migrate'].execute }
+    end
+
+    namespace :migrate do
+
+      task :redo => ['db:load_config'] do
+        FourthBase.on_base { Rake::Task['db:migrate:redo'].execute }
+      end
+
+      task :up => ['db:load_config'] do
+        FourthBase.on_base { Rake::Task['db:migrate:up'].execute }
+      end
+
+      task :down => ['db:load_config'] do
+        FourthBase.on_base { Rake::Task['db:migrate:down'].execute }
+      end
+
+      task :status => ['db:load_config'] do
+        FourthBase.on_base { Rake::Task['db:migrate:status'].execute }
+      end
+
+    end
+
+    task :rollback => ['db:load_config'] do
+      FourthBase.on_base { Rake::Task['db:rollback'].execute }
+    end
+
+    task :forward => ['db:load_config'] do
+      FourthBase.on_base { Rake::Task['db:forward'].execute }
+    end
+
+    task :abort_if_pending_migrations do
+      FourthBase.on_base { Rake::Task['db:abort_if_pending_migrations'].execute }
+    end
+
+    task :version => ['db:load_config'] do
+      FourthBase.on_base { Rake::Task['db:version'].execute }
+    end
+
+    namespace :schema do
+
+      task :load do
+        FourthBase.on_base { Rake::Task['db:schema:load'].execute }
+      end
+
+    end
+
+    namespace :structure do
+
+      task :load do
+        FourthBase.on_base { Rake::Task['db:structure:load'].execute }
+      end
+
+    end
+
+    namespace :test do
+
+      task :purge do
+        FourthBase.on_base { Rake::Task['db:test:purge'].execute }
+      end
+
+      task :load_schema do
+        FourthBase.on_base { Rake::Task['db:test:load_schema'].execute }
+      end
+
+      task :load_structure do
+        FourthBase.on_base { Rake::Task['db:test:load_structure'].execute }
+      end
+
+      task :prepare do
+        FourthBase.on_base { Rake::Task['db:test:prepare'].execute }
+      end
+
+    end
+
+  end
+end
+
+%w{
+  create:all create drop:all purge:all purge
+  migrate migrate:status abort_if_pending_migrations
+  schema:load structure:load
+  test:purge test:load_schema test:load_structure test:prepare
+}.each do |name|
+  task = Rake::Task["db:#{name}"] rescue nil
+  next unless task && FourthBase::Railtie.run_with_db_tasks?
+  task.enhance do
+    Rake::Task["db:load_config"].invoke
+    Rake::Task["db:fourth_base:#{name}"].invoke
+  end
+end

data/lib/fourth_base/databases_rails_five.rake

@@ -0,0 +1,22 @@
+namespace :db do
+  namespace :fourth_base do
+    task "drop:_unsafe" do
+      FourthBase.on_base { Rake::Task['db:drop:_unsafe'].execute }
+    end
+
+    namespace :migrate do
+      task :reset => ['db:fourth_base:drop:_unsafe', 'db:fourth_base:create', 'db:fourth_base:migrate']
+    end
+  end
+end
+
+%w{
+  drop:_unsafe
+}.each do |name|
+  task = Rake::Task["db:#{name}"] rescue nil
+  next unless task && FourthBase::Railtie.run_with_db_tasks?
+  task.enhance do
+    Rake::Task["db:load_config"].invoke
+    Rake::Task["db:fourth_base:#{name}"].invoke
+  end
+end

data/lib/fourth_base/databases_rails_four.rake

@@ -0,0 +1,22 @@
+namespace :db do
+  namespace :fourth_base do
+    task :drop do
+      FourthBase.on_base { Rake::Task['db:drop'].execute }
+    end
+
+    namespace :migrate do
+      task :reset => ['db:fourth_base:drop', 'db:fourth_base:create', 'db:fourth_base:migrate']
+    end
+  end
+end
+
+%w{
+  drop
+}.each do |name|
+  task = Rake::Task["db:#{name}"] rescue nil
+  next unless task && FourthBase::Railtie.run_with_db_tasks?
+  task.enhance do
+    Rake::Task["db:load_config"].invoke
+    Rake::Task["db:fourth_base:#{name}"].invoke
+  end
+end

data/lib/fourth_base/forced.rb

@@ -0,0 +1,21 @@
+module FourthBase
+  module Forced
+
+    def connection_pool
+      FourthBase::Base.connection_pool
+    end
+
+    def retrieve_connection
+      FourthBase::Base.retrieve_connection
+    end
+
+    def connected?
+      FourthBase::Base.connected?
+    end
+
+    def remove_connection(klass = self)
+      FourthBase::Base.remove_connection
+    end
+
+  end
+end

data/lib/fourth_base/on_base.rb

@@ -0,0 +1,36 @@
+module FourthBase
+
+  mattr_accessor :is_on_base, instance_accessor: false
+  self.is_on_base = false
+
+  def self.on_base
+    already_on_base = is_on_base
+    if already_on_base
+      yield
+      return
+    end
+    original_config = ActiveRecord::Tasks::DatabaseTasks.current_config
+    original_configurations = ActiveRecord::Base.configurations
+    original_migrations_path = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
+    original_db_dir = ActiveRecord::Tasks::DatabaseTasks.db_dir
+    ActiveRecord::Tasks::DatabaseTasks.current_config = config
+    ActiveRecord::Base.configurations = original_configurations[Railtie.config_key]
+    ActiveRecord::Base.establish_connection(config)
+    ActiveRecord::Tasks::DatabaseTasks.migrations_paths = [FourthBase::Railtie.fullpath('migrate')]
+    ActiveRecord::Tasks::DatabaseTasks.db_dir = FourthBase::Railtie.fullpath
+    ActiveRecord::Migrator.migrations_paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
+    self.is_on_base = true
+    yield
+  ensure
+    unless already_on_base
+      ActiveRecord::Base.configurations = original_configurations
+      ActiveRecord::Tasks::DatabaseTasks.migrations_paths = original_migrations_path
+      ActiveRecord::Tasks::DatabaseTasks.db_dir = original_db_dir
+      ActiveRecord::Migrator.migrations_paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
+      ActiveRecord::Tasks::DatabaseTasks.current_config = original_config
+      ActiveRecord::Base.establish_connection(original_config)
+      self.is_on_base = false
+    end
+  end
+
+end

data/lib/fourth_base/railtie.rb

@@ -0,0 +1,52 @@
+module FourthBase
+  class Railtie < Rails::Railtie
+
+    config.fourth_base = ActiveSupport::OrderedOptions.new
+    config.fourth_base.path = 'db/fourthbase'
+    config.fourth_base.config_key = 'fourthbase'
+    config.fourth_base.run_with_db_tasks = true
+
+    config.after_initialize do |app|
+      fourthbase_dir = app.root.join(config.fourth_base.path)
+      FileUtils.mkdir(fourthbase_dir) unless File.directory?(fourthbase_dir)
+    end
+
+    rake_tasks do
+      load 'fourth_base/databases.rake'
+      
+      if Rails.version.to_i == 4
+        load 'fourth_base/databases_rails_four.rake'
+      else
+        load 'fourth_base/databases_rails_five.rake'
+      end
+
+    end
+
+    generators do
+      require 'rails/fourth_base/generators/migration_generator'
+    end
+
+    initializer 'fourth_base.add_watchable_files' do |app|
+      fourthbase_dir = app.root.join(config.fourth_base.path)
+      config.watchable_files.concat ["#{fourthbase_dir}/schema.rb", "#{fourthbase_dir}/structure.sql"]
+    end
+
+    def config_path
+      config.fourth_base.path
+    end
+
+    def config_key
+      config.fourth_base.config_key
+    end
+
+    def run_with_db_tasks?
+      config.fourth_base.run_with_db_tasks
+    end
+
+    def fullpath(extra=nil)
+      path = Rails.root.join(config.fourth_base.path)
+      (extra ? path.join(path, extra) : path).to_s
+    end
+
+  end
+end

data/lib/fourth_base/test_help.rb

@@ -0,0 +1,11 @@
+if defined?(ActiveRecord::Base)
+
+  # Support test schema sync for Rails 4.2.x and up.
+  if ActiveRecord::Migration.respond_to? :maintain_test_schema!
+    FourthBase.on_base do
+      ActiveRecord::Migration.maintain_test_schema!
+    end
+  end
+
+
+end

data/lib/fourth_base/version.rb

@@ -0,0 +1,3 @@
+module FourthBase
+  VERSION = File.read(File.expand_path("../../../VERSION", __FILE__)).chomp
+end

data/lib/fourthbase.rb

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

data/lib/rails/fourth_base/generators/migration_generator.rb

@@ -0,0 +1,25 @@
+require 'rails/generators'
+require 'rails/generators/active_record'
+require 'rails/generators/active_record/migration/migration_generator'
+
+module FourthBase
+  class MigrationGenerator < ActiveRecord::Generators::MigrationGenerator
+
+    source_root ActiveRecord::Generators::MigrationGenerator.source_root
+
+    def self.desc
+      require 'rails/generators/rails/migration/migration_generator'
+      Rails::Generators::MigrationGenerator.desc
+    end
+
+    include(Module.new{
+
+      def migration_template(*args)
+        args[1].sub! 'db/migrate', "#{Railtie.config_path}/migrate" if args[1]
+        super(*args)
+      end
+
+    })
+
+  end
+end

data/test/cases/dbtask_test.rb

@@ -0,0 +1,248 @@
+require 'test_helper'
+
+class DbTaskTest < FourthBase::TestCase
+
+  def test_db_create
+    refute_dummy_databases
+    run_db :create
+    assert_dummy_databases
+  end
+
+  def test_db_create_all
+    refute_dummy_databases
+    run_db 'create:all'
+    assert_dummy_databases
+  end
+
+  def test_db_setup
+    run_db :create
+    run_db :migrate
+    assert_dummy_databases
+    run_db :drop
+    refute_dummy_databases
+    run_db :setup
+    assert_dummy_databases
+  end
+
+  def test_db_drop
+    run_db :create
+    run_db :drop
+    refute_dummy_databases
+  end
+
+  def test_db_drop_all
+    run_db :create
+    run_db 'drop:all'
+    refute_dummy_databases
+  end
+
+  def test_db_purge_all
+    skip 'Rails 4.2 & Up' unless rails_42_up?
+    run_db :create
+    run_db :migrate
+    assert_dummy_databases
+    run_db 'purge:all'
+    establish_connection
+    assert_no_tables
+  end
+
+  def test_db_purge
+    skip 'Rails 4.2 & Up' unless rails_42_up?
+    run_db :create
+    run_db :migrate
+    assert_dummy_databases
+    run_db :purge
+    establish_connection
+    assert_no_tables
+  end
+
+  def test_db_migrate
+    run_db :create
+    run_db :migrate
+    # First database and schema.
+    schema = File.read(dummy_schema)
+    assert_match %r{version: 20141214142700}, schema
+    assert_match %r{create_table "users"}, schema
+    assert_match %r{create_table "posts"}, schema
+    refute_match %r{create_table "comments"}, schema
+    assert_connection_tables ActiveRecord::Base, ['users', 'posts']
+    # Fourth database and schema.
+    fourthbase_schema = File.read(dummy_fourthbase_schema)
+    assert_match %r{version: 20151202075826}, fourthbase_schema
+    refute_match %r{create_table "users"}, fourthbase_schema
+    refute_match %r{create_table "posts"}, fourthbase_schema
+    assert_match %r{create_table "comments"}, fourthbase_schema
+    assert_connection_tables FourthBase::Base, ['comments']
+  end
+
+  def test_fourthbase_migrate_updown
+    run_db :create
+    run_db :migrate
+    assert_match(/no migration.*20151202075826/i, run_db('migrate:down VERSION=20151202075826', :stderr))
+    run_fourthbase 'migrate:down VERSION=20151202075826'
+    fourthbase_schema = File.read(dummy_fourthbase_schema)
+    refute_match %r{version: 20151202075826}, fourthbase_schema
+    refute_match %r{create_table "comments"}, fourthbase_schema
+    assert_match(/no migration.*20151202075826/i, run_db('migrate:up VERSION=20151202075826', :stderr))
+    run_fourthbase 'migrate:up VERSION=20151202075826'
+    fourthbase_schema = File.read(dummy_fourthbase_schema)
+    assert_match %r{version: 20151202075826}, fourthbase_schema
+    assert_match %r{create_table "comments"}, fourthbase_schema
+  end
+
+  def test_fourthbase_migrate_reset
+    run_db :create
+    run_db :migrate
+    fourthbase_schema = File.read(dummy_fourthbase_schema)
+    assert_match %r{version: 20151202075826}, fourthbase_schema
+    assert_match %r{create_table "comments"}, fourthbase_schema
+    FileUtils.rm_rf dummy_fourthbase_schema
+    run_fourthbase 'migrate:reset'
+    fourthbase_schema = File.read(dummy_fourthbase_schema)
+    assert_match %r{version: 20151202075826}, fourthbase_schema
+    assert_match %r{create_table "comments"}, fourthbase_schema
+  end
+
+  def test_fourthbase_migrate_redo
+    run_db :create
+    run_db :migrate
+    fourthbase_schema = File.read(dummy_fourthbase_schema)
+    assert_match %r{version: 20151202075826}, fourthbase_schema
+    assert_match %r{create_table "comments"}, fourthbase_schema
+    FileUtils.rm_rf dummy_fourthbase_schema
+    run_fourthbase 'migrate:redo'
+    fourthbase_schema = File.read(dummy_fourthbase_schema)
+    assert_match %r{version: 20151202075826}, fourthbase_schema
+    assert_match %r{create_table "comments"}, fourthbase_schema
+    # Can redo latest FourthBase migration using previous VERSION env.
+    version = dummy_migration[:version]
+    run_db :migrate
+    assert_match %r{version: #{version}}, File.read(dummy_fourthbase_schema)
+    establish_connection
+    Comment.create! body: 'test', user_id: 420
+    run_fourthbase 'migrate:redo VERSION=20151202075826'
+    fourthbase_schema = File.read(dummy_fourthbase_schema)
+    assert_match %r{version: #{version}}, fourthbase_schema
+    assert_match %r{create_table "comments"}, fourthbase_schema
+    establish_connection
+    assert_nil Comment.first
+  end
+
+  def test_fourthbase_migrate_status
+    run_db :create
+    stream = rails_42_up? ? :stderr : :stdout
+    assert_match %r{migrations table does not exist}, run_fourthbase('migrate:status', stream)
+    run_db :migrate
+    assert_match %r{up.*20151202075826}, run_fourthbase('migrate:status')
+    version = dummy_migration[:version]
+    status = run_fourthbase('migrate:status')
+    assert_match %r{up.*20151202075826}, status
+    assert_match %r{down.*#{version}}, status
+  end
+
+  def test_fourthbase_forward_and_rollback
+    run_db :create
+    run_db :migrate
+    fourthbase_schema = File.read(dummy_fourthbase_schema)
+    assert_match %r{version: 20151202075826}, fourthbase_schema
+    refute_match %r{create_table "foos"}, fourthbase_schema
+    version = dummy_migration[:version] # ActiveRecord does not support start index 0.
+    run_fourthbase :forward
+    fourthbase_schema = File.read(dummy_fourthbase_schema)
+    assert_match %r{version: #{version}}, fourthbase_schema
+    assert_match %r{create_table "foos"}, fourthbase_schema
+    run_fourthbase :rollback
+    fourthbase_schema = File.read(dummy_fourthbase_schema)
+    assert_match %r{version: 20151202075826}, fourthbase_schema
+    refute_match %r{create_table "foos"}, fourthbase_schema
+  end
+
+  def test_db_test_purge
+    run_db :create
+    assert_dummy_databases
+    run_db 'test:purge'
+    establish_connection
+    assert_no_tables
+  end
+
+  def test_db_test_load_schema
+    run_db :create
+    assert_dummy_databases
+    run_db 'test:purge'
+    run_db :migrate
+    Dir.chdir(dummy_root) { `rake db:test:load_schema` }
+    establish_connection
+    assert_connection_tables ActiveRecord::Base, ['users', 'posts']
+    assert_connection_tables FourthBase::Base, ['comments']
+  end
+
+  def test_abort_if_pending
+    run_db :create
+    run_db :migrate
+    assert_equal "", run_db(:abort_if_pending_migrations, :stderr)
+    version = dummy_migration[:version]
+    capture(:stderr) do
+      stdout = run_db :abort_if_pending_migrations
+      assert_match(/1 pending migration/, stdout)
+      assert_match(/#{version}/, stdout)
+    end
+  end
+
+  def test_db_test_load_structure
+    run_db :create
+    assert_dummy_databases
+    run_db 'test:purge'
+    Dir.chdir(dummy_root) { `env SCHEMA_FORMAT=sql rake db:migrate` }
+    Dir.chdir(dummy_root) { `rake db:test:load_structure` }
+    establish_connection
+    assert_connection_tables ActiveRecord::Base, ['users', 'posts']
+    assert_connection_tables FourthBase::Base, ['comments']
+  end
+
+  def test_fourthbase_version
+    run_db :create
+    assert_match(/version: 0/, run_fourthbase(:version))
+    run_db :migrate
+    assert_match(/version: 20141214142700/, run_db(:version))
+    assert_match(/version: 20151202075826/, run_fourthbase(:version))
+  end
+
+  def test_fourthbase_db_tasks_disabled
+    refute_dummy_databases
+    run_db :create, :stdout, false
+    assert_dummy_created_but_not_fourthbase
+  end
+
+  private
+
+  def assert_dummy_created_but_not_fourthbase
+    assert_equal 'base.sqlite3', dummy_database_sqlite
+    refute_match(/fourthbase_test/, `mysql -uroot -e "SHOW DATABASES"`)
+  end
+
+  def assert_no_tables
+    if ActiveRecord::Base.connection.respond_to? :data_sources
+      assert_equal [], ActiveRecord::Base.connection.data_sources
+      assert_equal [], FourthBase::Base.connection.data_sources
+    else
+      assert_equal [], ActiveRecord::Base.connection.tables
+      assert_equal [], FourthBase::Base.connection.tables
+    end
+  end
+
+  def assert_connection_tables(model, expected_tables)
+    establish_connection
+
+    if ActiveRecord::Base.connection.respond_to? :data_sources
+      tables = model.connection.data_sources
+    else
+      tables = model.connection.tables
+    end
+
+    expected_tables.each do |table|
+      message = "Expected #{model.name} tables #{tables.inspect} to include #{table.inspect}"
+      assert tables.include?(table), message
+    end
+  end
+
+end