multiple_dbs 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: af9c0af78926a4506ef7eeb69316619bc61c35f0
+  data.tar.gz: de2bfdfa8fdc35f92efdaa58f69ff0a3b8eeb256
+SHA512:
+  metadata.gz: d036f11d65f5637c5d4c6a01cec12573d6fa23875309e43be5a606b6593c0d3269bd3a9fd54bfe7e529985d5b4c3579ae0741d8b038f21a39355295af257dfed
+  data.tar.gz: 93a80a61c13648cf9ec5d13c690649cf1318fca6f8714b5e2d1b1f7ebd29850bc4626596997862759bf4196ed1cc4913a6b1646df48ebdeb53be25871ea1ac3a

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Yonga
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,341 @@
+# MultipleDbs
+So, your rails application needs to handle n databases. Well my friend,
+this is your solution. This gem allows you to handle all your databases
+connections, either for different databases that share the same entity
+relationship model or for different databases with different entity
+relationship models.
+
+## Usage
+
+multiple_dbs creates a subclass for the models you want to handle in multiple
+databases and one subclass for each connection. By doing this, each connection is
+handled by it's own subclass, preventing switching between connections, which add a high computational cost.
+
+#### IMPORTANT.
+The following examples assume that you define 3 databases: db1, db2 and db3.
+
+Before you start, follow the installation instructions [here](https://github.com/yonga9121/multiple_dbs#installation) and please read all this
+document, especially if your project is already running or
+already has a database with migrations and stuff.
+
+### Generate models.
+
+If you want to generate a model for all the databases, run
+```bash
+$ rails g multiple_dbs_model user email:string
+```
+
+If you want to generate a model for a specific databases, run
+```bash
+$ rails g multiple_dbs_model user email:string --only=db1 db3
+```
+
+If you want to generate a model skipping a specific databases, run
+```bash
+$ rails g multiple_dbs_model user email:string --skip=db1 db3
+```
+
+You will find all migrations in the folder db/your_database/migrate.
+The schema and seed files can be found in the folder db/your_database.
+
+#### NOTE:
+If you already have models, migrations and a schema file, and want to manage that
+initial database with the multiple_dbs gem (recommended), you should create the database using the multiple_dbs_initializer generator and pass said database name as an argument. Check the ["How to start if already have a database ?"](https://github.com/yonga9121/multiple_dbs#how-to-start-if-already-have-a-database-) section for more information.
+
+If you DO NOT want to override the default database.yml file, add as an option
+--not_override=true
+
+
+### Generate Migrations
+
+If you want to generate a migration for all the databases, run
+```bash
+$ rails g multiple_dbs_migration add_column_password_to_users password:string
+```
+
+If you want to a generate migration for a specific database, run
+```bash
+$ rails g multiple_dbs_migration add_column_password_to_users password:string --only=db1 db3
+```
+
+If you want to generate a migration skipping a specific database, run
+```bash
+$ rails g multiple_dbs_migration add_column_password_to_users password:string --skip=db1 db2
+```
+
+#### NOTE:
+If you already have models, migrations and a schema file, and want to manage that
+initial database with the multiple_dbs gem (recommended), you should create the database using the multiple_dbs_initializer generator and pass said database name as an argument. Check the ["How to start if already have a database ?"](https://github.com/yonga9121/multiple_dbs#how-to-start-if-already-have-a-database-) section for more information.
+
+If you DO NOT want to override the default database.yml file, add as an option
+--not_override=true
+
+### Setting up your application_controller
+
+Add this tou your controller. Be sure to specify the database_name in the method mdb_name.
+
+This will turn on the connection to the specified database.
+
+```ruby
+ def mdb_name
+   Thread.current[:mdb_name] ||= nil # ...change this for somthing that gives you the database name, like: 'db1' or 'client1_database'. You can use the request headers or the params or an object in the database or the request domain...
+ end
+
+ before_filter do
+   MultipleDbs.validate_connection(mdb_name)
+ end
+```
+
+### Setting up your models
+
+Assuming that you create a User model and it has many Posts.
+
+The User and Post models should look like this:
+```ruby
+# app/models/user.rb
+class User < ApplicationRecord
+  make_connectable_class do |db|
+    has_many :posts, class_name: "Post#{db}"
+  end
+end
+
+# app/models/post.rb
+class Post < ApplicationRecord
+  make_connectable_class do |db|
+    belongs_to :user, foreign_key: "user_id", class_name: "User#{db}"
+  end
+end
+```
+Here, you associate the models between databases, by using classes PostDb1, PostDb2 and PostDb3 associated with classes UserDb1, UserDb2 and UserDb3 respectively.
+
+In case you don't need the association through all the databases, for example, the
+database db1, your models should look like this.
+
+```ruby
+# app/models/user.rb
+class User < ApplicationRecord
+  make_connectable_class do |db|
+    has_many :posts, class_name: "PostDb1"
+  end
+end
+
+# app/models/post.rb
+class Post < ApplicationRecord
+  make_connectable_class do |db|
+    belongs_to :user, foreign_key: "user_id", class_name: "UserDb1"
+  end
+end
+```
+Here, you associate the models between databases, by using class PostDb1 associated with classes UserDb1, UserDb2 and UserDb3.
+
+In case you don't need to define a class for all your databases, your models should look like this.
+```ruby
+# app/models/user.rb
+class User < ApplicationRecord
+  make_connectable_class(only: [:db1,:db3]) do |db|
+    has_many :posts, class_name: "Post#{db}"
+  end
+end
+
+# app/models/post.rb
+class Post < ApplicationRecord
+  make_connectable_class(only: [:db1,:db3]) do |db|
+    belongs_to :user, foreign_key: "user_id", class_name: "User#{db}"
+  end
+end
+```
+
+Here, you associate the models between databases, by using classes PostDb1, PostDb2 and PostDb3 associated with classes UserDb1 and UserDb3.
+
+### Using the subclasses
+
+You have two options for using a subclass that handles a connection.
+
+- 1. Get the class from the base model
+
+  Use the model User to get the desired class.
+
+  ```ruby
+    user_class = User.multiple_class(:db1) # or User.mdb(:db1)
+    user_class.create(email: "someone@email.com")
+  ```
+  This is useful if your client sends you the database for data storage or transaction runs.
+
+- 2. Using the raw constant
+
+  Before you can use the raw constant you must be sure that the connection to the database is on.
+  You can do this using MultipleDbs.validate_connection(dat_name) passing the database name as a parameter.
+
+  Use the UserDb1 class as usual
+  ```ruby
+    UserDb1.create(email: "someone@email.com")
+  ```
+
+ - 3. Using classes from different connections
+
+  In order to use different connections you must be sure that the connection from each database is on.
+  ```ruby
+  # somewhere in your code before you use the classes
+
+  MultipleDbs.validate_connection(:db1)
+  MultipleDbs.validate_connection(:db2)
+
+
+  # using the raw classes
+
+  puts UserDb1.first.inspect
+  puts UserDb2.first.inspect
+
+  # using the model to get the desired class
+
+  puts User.mdb(:db1).first.inspect
+  puts User.mdb(:db2).first.inspect
+  ```
+
+## Installation
+
+Add this line to your application's Gemfile:
+```ruby
+gem 'multiple_dbs'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install multiple_dbs
+```
+
+Let's setup our connections. We are going to create all our configuration files
+and all the stuff needed. Call the multiple_dbs_initializer generator and pass
+as an argument the databases names. You can also pass as options the specific
+database configuration.
+
+Run in your terminal
+```bash
+$ rails g multiple_dbs_initializer my_database1 my_database2
+```
+
+If you need to configure the database connections (adapter, username,
+etc), pass the options you want. Allowed options are: adapter,encoding,pool,username,password
+
+Run in your terminal
+```bash
+$ rails g multiple_dbs_initializer my_database1 my_database2
+--development=username:goku password:ukog adapter:mysql2
+--test=username:gohan password:nahog adapter:postgresql pool:2
+--production=username:seriusname password:enviromentvariablepls pool:20
+```
+
+Run the help command for more information
+```bash
+$ rails g multiple_dbs_initializer --help
+```
+
+We just need one more thing... Read the section according to your rails version
+
+### Rails >= 5.x.x
+
+Add this line to your application_record.rb file so you ApplicationRecord class
+looks like this.
+```ruby
+# app/models/application_record.rb
+class ApplicationRecord < ActiveRecord::Base
+  include MultipleDbs::MultiConnectable # this line
+  self.abstract_class = true
+end
+
+```
+
+### How to start if already have a database ?.
+
+If you already have a database and want to replicate the entity relationship model in your new databases you can do the following:
+
+- Install the gem.
+- Run the multiple_dbs_initializer and configure your database connections.
+- If you want to copy the migrations from the default folder db/migrate into all your new databases, run in your terminal
+```bash
+$ rails "mdbs:replicate_default_database"
+```
+
+This command will copy your db/migrate folder into each of your databases folders, like db/your_database.
+
+- If you want to copy the migrations from the default folder db/migrate into an specific database, run in your terminal:
+```bash
+$ rails "mdbs:replicate_default_database_into[your_database]"
+```
+
+This command will copy your db/migrate folder into db/your_database
+
+- If you want to copy a specific migration from the default folder db/migrate into all your databases, run in your terminal:
+```bash
+$ rails "mdbs:copy_migration_from_default[file_name.rb]"
+```
+
+- If you want to copy a specific migration from the default folder db/migrate into an specific database, run in your terminal:
+```bash
+$ rails "mdbs:copy_migration_from_default_into[file_name.rb, database_name]"
+```
+
+- after you copy the migrations you want into the databases you want, migrate your databases, run in your terminal:
+```bash
+$ rails mdbs:migrate
+```
+
+
+### Manage the databases
+multiple_dbs comes with a list of useful tasks that you can find in your project
+after the gem was installed.
+
+Run in your terminal
+```bash
+$ rake --tasks
+```
+
+You will find all the tasks under the namespace "mdbs"
+
+To create all the databases.
+```bash
+$ rails mdbs:create
+```
+
+To create a specific database
+```bash
+$ rails mdbs:your_database_name:create
+```
+
+To setup all the databases.
+```bash
+$ rails mdbs:setup
+```
+
+To setup a specific database.
+```bash
+$ rails mdbs:your_database_name:setup
+```
+
+To migrate all the databases.
+```bash
+$ rails mdbs:migrate
+```
+
+To migrate a specific database.
+```bash
+$ rails mdbs:your_database_name:migrate
+```
+
+You can pass the standard rails options as arguments to the tasks.
+
+Please. Please! check the tasks under the namespace "mdbs"
+Run in your terminal
+```bash
+$ rake --tasks
+```
+
+
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'MultipleDbs'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/generators/multiple_dbs_initializer/USAGE

@@ -0,0 +1,23 @@
+Description:
+    You must use this generator to start using the multiple_dbs gem .
+    It creates the files needed to work with your databases.
+      Those files are:
+      - An initializer that define a constant with the databases names that you
+        give as an argument and the constants that store the databases configuration.
+      - the DBNAME_database.yml configuration files for each one of the databases.
+      - the database.yml. This file is needed by rails as default.
+    You can pass as options the configuration for each environment
+    (development, production, test).
+
+Example:
+    rails generate multiple_dbs_initializer your_database your_database2 your_database3
+
+    This will create and override if exist the following files:
+        config/initializers/multiple_dbs_initializer.rb
+        config/multiple_dbs/your_database_database.yml
+        config/multiple_dbs/your_database2_database.yml
+        config/multiple_dbs/your_database3_database.yml
+        config/database.yml
+
+Example with Options:
+    rails generate multiple_dbs_initializer your_database your_database2 your_database3 --development=username:super password:cool --test=adapter:mysql2 pool:2 --production=username:imsecure

data/lib/generators/multiple_dbs_initializer/multiple_dbs_initializer_generator.rb

@@ -0,0 +1,131 @@
+class MultipleDbsInitializerGenerator < Rails::Generators::Base
+  source_root File.expand_path("../templates", __FILE__)
+
+  ## @@default_db_config
+  #  default database configuration
+  @@default_db_config = {
+    "adapter"=> "postgresql",
+    "encoding"=> "unicode",
+    "pool"=> 5,
+    "username"=> "root",
+    "password"=> "toor",
+  }
+
+  ## databases = [:db1, :db2]
+  # an array that stores the databases names.
+  argument :databases, type: :array, default: [:db1, :db2]
+
+  ## development = @@default_db_config
+  #  a hash that allows the user to change the default database configuration
+  #  for the development environment through the options
+  class_option :development, type: :hash, default: @@default_db_config
+  ## production = @@default_db_config
+  #  a hash that allows the user to change the default database configuration
+  #  for the production environment through the options
+  class_option :production, type: :hash, default: @@default_db_config
+  ## test = @@default_db_config
+  #  a hash that allows the user to change the default database configuration
+  #  for the test environment through the options
+  class_option :test, type: :hash, default: @@default_db_config
+
+  ## not_override
+  # If false override the config/database.yml otherwise not override it
+  class_option :not_override, type: :boolean, default: true
+
+  ## define_multiple_dbs_constant
+  #  Create the multiple_dbs_initializer.rb file.
+  #  This file define the MultipleDbs::DBS constant
+  #  and the MultipleDbs::DbConnection per database.
+  #  Also delete the config/multiple_dbs folder and
+  #  create the ymls files that store the database
+  #  configuration
+  def define_multiple_dbs_constant
+    copy_file "initializer.rb", "config/initializers/multiple_dbs_initializer.rb"
+    insert_into_file "config/initializers/multiple_dbs_initializer.rb",
+    %Q{\tDBS=#{databases.map{|db| db.to_s.underscore.to_sym}}
+      run_setup\n}, after: "# Your databases.\n", verbose: false
+    remove_file "config/multiple_dbs", verbose: false
+    inject_into_class "app/controllers/application_controller.rb", ApplicationController,
+    %Q{\t\t# def mdb_name
+      #   Thread.current[:mdb_name] ||= ... somthing that gives you the database name, like: 'db1' or 'client1_database'
+      # end
+      # before_filter do
+      #   MultipleDbs.validate_connection(mdb_name)
+      # end\n}
+    databases.each do |db|
+      create_database_config_file db
+    end
+    create_database_config_file if !options.not_override
+  end
+
+  private
+
+
+  ## create_database_config_file
+  #  create the configuration yml file for the given database name
+  #  if the database name is null then the default rails configuration file is
+  #  Overwritten
+  def create_database_config_file(db = nil)
+    fpath = db ? "/multiple_dbs/#{db}_database.yml" : "/database.yml"
+    db ||= databases.first
+    copy_file "config_db.yml", "config#{fpath}"
+
+    insert_into_file "config#{fpath}",
+    %Q{#{options.development["adapter"] ? options.development["adapter"] : @@default_db_config["adapter"] } },
+    before: "#development_adapter", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{options.development["encoding"] ? options.development["encoding"] : @@default_db_config["encoding"] } },
+    before: "#development_encoding", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{options.development["pool"] ? options.development["pool"] : @@default_db_config["pool"] } },
+    before: "#development_pool", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{db}_development },
+    before: "#development_database", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{options.development["username"] ? options.development["username"] : @@default_db_config["username"] } },
+    before: "#development_username", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{options.development["password"] ? options.development["password"] : @@default_db_config["password"] } },
+    before: "#development_psw", verbose: false, force: true
+
+    insert_into_file "config#{fpath}",
+    %Q{#{options.production["adapter"] ? options.production["adapter"] : @@default_db_config["adapter"] } },
+    before: "#production_adapter", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{options.production["encoding"] ? options.production["encoding"] : @@default_db_config["encoding"] } },
+    before: "#production_encoding", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{options.production["pool"] ? options.production["pool"] : @@default_db_config["pool"] } },
+    before: "#production_pool", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{db}_production },
+    before: "#production_database", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{options.production["username"] ? options.production["username"] : @@default_db_config["username"] } },
+    before: "#production_username", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{options.production["password"] ? options.production["password"] : @@default_db_config["password"] } },
+    before: "#production_psw", verbose: false, force: true
+
+    insert_into_file "config#{fpath}",
+    %Q{#{options.test["adapter"] ? options.test["adapter"] : @@default_db_config["adapter"] } },
+    before: "#test_adapter", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{options.test["encoding"] ? options.test["encoding"] : @@default_db_config["encoding"] } },
+    before: "#test_encoding", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{options.test["pool"] ? options.test["pool"] : @@default_db_config["pool"] } },
+    before: "#test_pool", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{db}_test },
+    before: "#test_database", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{options.test["username"] ? options.test["username"] : @@default_db_config["username"] } },
+    before: "#test_username", verbose: false, force: true
+    insert_into_file "config#{fpath}",
+    %Q{#{options.test["password"] ? options.test["password"] : @@default_db_config["password"] } },
+    before: "#test_psw", verbose: false, force: true
+  end
+
+end

data/lib/generators/multiple_dbs_initializer/templates/config_db.yml

@@ -0,0 +1,24 @@
+
+development:
+  adapter: #development_adapter
+  encoding: #development_encoding
+  pool: #development_pool
+  database: #development_database
+  password: #development_psw
+  username: #development_username
+
+production:
+  adapter: #production_adapter
+  encoding: #production_encoding
+  pool: #production_pool
+  database: #production_database
+  username: #production_username
+  password: #production_psw
+
+test:
+  adapter: #test_adapter
+  encoding: #test_encoding
+  pool: #test_pool
+  database: #test_database
+  username: #test_username
+  password: #test_psw

data/lib/generators/multiple_dbs_initializer/templates/initializer.rb

@@ -0,0 +1,8 @@
+module MultipleDbs
+  # Your databases.
+
+  module DbConnection
+    # DbConnection Constants.
+  end
+
+end

data/lib/generators/multiple_dbs_migration/USAGE

@@ -0,0 +1,14 @@
+Description:
+    Generate the migrations like the migration generator from rails but
+    create the files in the multiple_dbs databases.
+
+    You can use it as you usually use the rails migration generator
+
+    You can use the options:
+    --only and pass the name of the databases space separated. This only create
+           the migration in the specified databases
+    --skip and pass the name of the databases space separated. This not create
+           the migration in the specified databases
+
+Example:
+    rails g multiple_dbs_migration add_password_to_users password:string --only=db1 db3 --skip=db3

data/lib/generators/multiple_dbs_migration/multiple_dbs_migration_generator.rb

@@ -0,0 +1,25 @@
+require 'rails/generators/active_record/migration/migration_generator'
+
+class MultipleDbsMigrationGenerator < ActiveRecord::Generators::MigrationGenerator
+  source_root File.join(File.dirname(ActiveRecord::Generators::MigrationGenerator.instance_method(:create_migration_file).source_location.first), "templates")
+
+  class_option :only, type: :array, default: []
+  class_option :skip, type: :array, default: []
+
+  def create_migration_file
+    if MultipleDbs and MultipleDbs::DBS
+      set_local_assigns!
+      validate_file_name!
+      only_arr = options[:only].map{|o| o.to_sym }.delete_if{ |o| !MultipleDbs::DBS.include?(o)} if options[:only] and options[:only].any?
+      skip_arr = options[:skip].map{|s| s.to_sym }.delete_if{ |s| !MultipleDbs::DBS.include?(s)} if options[:skip] and options[:skip].any?
+      databases_list = (MultipleDbs::DBS & only_arr) if only_arr and only_arr.any?
+      databases_list = databases_list - skip_arr if skip_arr and skip_arr.any?
+      databases_list ||= MultipleDbs::DBS
+      databases_list.each do |branch|
+        migration_template @migration_template, "db/#{branch}/migrate/#{file_name}.rb"
+      end if databases_list.any?
+    else
+      puts "The multiple_dbs constant is not defined. The multiple_dbs generator must be runned first. Type in your console: rails g multiple_dbs --help"
+    end
+  end
+end

data/lib/generators/multiple_dbs_model/USAGE

@@ -0,0 +1,14 @@
+Description:
+    Generate the models like the model generator from rails but
+    create the files in the multiple_dbs databases.
+
+    You can use it as you usually use the rails model generator
+
+    You can use the options:
+    --only and pass the name of the databases space separated. This only create
+           the model in the specified databases
+    --skip and pass the name of the databases space separated. This not create
+           the model in the specified databases
+
+Example:
+    rails g multiple_dbs_model User email:string --only=db1 db3 --skip=db3

data/lib/generators/multiple_dbs_model/multiple_dbs_model_generator.rb

@@ -0,0 +1,26 @@
+require 'rails/generators/active_record/model/model_generator'
+
+class MultipleDbsModelGenerator < ActiveRecord::Generators::ModelGenerator
+  source_root File.join(File.dirname(ActiveRecord::Generators::ModelGenerator.instance_method(:create_migration_file).source_location.first), "templates")
+
+  class_option :only, type: :array, default: []
+  class_option :skip, type: :array, default: []
+
+  def create_migration_file
+    if MultipleDbs and MultipleDbs::DBS
+      return unless options[:migration] && options[:parent].nil?
+      attributes.each { |a| a.attr_options.delete(:index) if a.reference? && !a.has_index? } if options[:indexes] == false
+      only_arr = options[:only].map{|o| o.to_sym }.delete_if{ |o| !MultipleDbs::DBS.include?(o)} if options[:only] and options[:only].any?
+      skip_arr = options[:skip].map{|s| s.to_sym }.delete_if{ |s| !MultipleDbs::DBS.include?(s)} if options[:skip] and options[:skip].any?
+      databases_list = (MultipleDbs::DBS & only_arr) if only_arr and only_arr.any?
+      databases_list = databases_list - skip_arr if skip_arr and skip_arr.any?
+      databases_list ||= MultipleDbs::DBS
+      databases_list.each do |branch|
+        migration_template "../../migration/templates/create_table_migration.rb", "db/#{branch}/migrate/#{table_name}.rb"
+      end if databases_list.any?
+    else
+      puts "The multiple_dbs constant is not defined. The multiple_dbs generator must be runned first. Type in your console: rails g multiple_dbs --help"
+    end
+  end
+
+end

data/lib/multiple_dbs.rb

@@ -0,0 +1,7 @@
+require "multiple_dbs/railtie"
+require "multiple_dbs/multi_connectable"
+
+## MultipleDbs
+#  The MultipleDbs module.
+module MultipleDbs
+end

data/lib/multiple_dbs/multi_connectable.rb

@@ -0,0 +1,207 @@
+module MultipleDbs
+
+  def validate_connection(db)
+    conn_klass = const_get("Conn#{db.to_s.camelize}")
+    if conn_klass
+      ActiveRecord::Base.connection_handler.connection_pools.each do |pool|
+        Rails.logger.info "CONN FOUND" and return true if pool.spec.name == conn_klass.to_s
+      end
+      Rails.logger.info " CONN NOT FOUND. CONNECTION TO #{conn_klass}"
+      conn_klass.connection and return true
+    else
+      raise Exception.new("Undefined constant #{conn_klass}")
+    end
+  end
+  module_function :validate_connection
+
+  # This module should be included in your application ApplicationRecord.
+  # It define two class methods for your models. With this two
+  # methods you can setup and handle all the models from all the
+  # databases you defined.
+  module MultiConnectable
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    module ClassMethods
+
+      # This method lookup for the subclass related to the database that you pass
+      # as an argument and the model in wich you are calling the method.
+      # It use Object.const_get to lookup for the constant and also call
+      # the method multiple_relations so the relations match the classes
+      # that must be matched.
+      def multiple_class(connectable_type)
+        klass = Object.const_get("#{self.name}#{connectable_type.capitalize}")
+        klass.muliple_relations
+        klass
+      end
+      alias :mdb :multiple_class
+
+      # This method define one subclass for each database you define. Why?
+      # becouse each subclass handle the connection with the specifyed database
+      # and becouse of that we does not have to turn off and on the connections
+      # between databases. It's simple, if you have a User model and 3 databases
+      # defined db1, db2, db3 this method set the constants UserDb1, UserDb2
+      # and UserDb3. UserDb1 handle the connection with the database db1 and so on.
+      #
+      # EXAMPLE:
+      # class User < ApplicationRecord
+      #   make_connectable_class do |db|
+      #     has_many :post, class_name: "Post#{db}"
+      #   end
+      # end
+      #
+      def make_connectable_class(options = {},&block)
+        only = options[:only]
+        only = only.delete_if{ |o| !MultipleDbs::DBS.include?(o) } if only and only.any?
+        database_list = (MultipleDbs::DBS & only) if only and only.any?
+        database_list ||=  MultipleDbs::DBS
+        database_list.each do |db|
+          class_eval do
+            Object.const_set("#{self.name}#{db.capitalize}", Class.new(self) do
+              class_eval do
+                # This constant store the name of the database that this subclass
+                # is handling
+                const_set("CONNECTABLE_TYPE",db.capitalize)
+
+                # This variable will store the connection_pool that is going to
+                # handle the connections for the database. Just initializing  the constant
+                Thread.current[const_get("CONNECTABLE_TYPE").to_s.underscore + "_connection"] = nil
+
+                # This filter calls the method multiple_relations
+                # setting the relations to the database they should be set
+                before_validation :muliple_relations
+                # This filter calls the method multiple_relations
+                # setting the relations to the database they should be set
+                after_find :muliple_relations
+
+
+                # This variable store the block given  by the user...
+                # It is thought to have the definition of the model relations
+                # and is used my the method multiple_relations to set them adequately
+                @connectable_relations = block_given? ? block : nil
+
+                # This method call the block given by the user. If that block contains
+                # the definition of the relations parametrized like this:
+                #
+                # class User < ApplicationRecord
+                #   make_connectable_class do |db|
+                #     has_many :post, class_name: "Post#{db}"
+                #   end
+                # end
+                #
+                # it will set the :post relation to the database handle by this
+                # subclass
+                def self.muliple_relations
+                  @connectable_relations.call( const_get("CONNECTABLE_TYPE") ) if @connectable_relations
+                end
+
+                # return the database name of the database that this subclass
+                # is related to
+                def self.connectable_type
+                  const_get("CONNECTABLE_TYPE")
+                end
+
+
+                # Override the connection method. Search the connection_pool that
+                # is handle the database connection, assign it to the
+                # Thread.current[const_get("CONNECTABLE_TYPE").to_s.underscore + "_connection"]
+                # vairable
+                def self.connection
+                  self.connection_handler.connection_pools.each do |pool|
+                    if pool.spec.config[:database] == eval('DBConnection' + const_get("CONNECTABLE_TYPE").to_s).connection["database"]
+                      return Thread.current[const_get("CONNECTABLE_TYPE").to_s.underscore + "_connection"] = pool.connection
+                    end
+                  end
+                end
+
+                private
+
+                # return the database name of the database that this subclass
+                # is related to
+                def connectable_type
+                  const_get("CONNECTABLE_TYPE")
+                end
+
+                # Call the class method multiple_relations.
+                # This method call the block given by the user. If that block contains
+                # the definition of the relations parametrized like this:
+                #
+                # class User < ApplicationRecord
+                #   make_connectable_class do |db|
+                #     has_many :post, class_name: "Post#{db}"
+                #   end
+                # end
+                #
+                # it will set the :post relation to the database handle by this
+                # subclass
+                def muliple_relations
+                  self.class.muliple_relations
+                end
+              end
+            end)
+            # Set the relations for the current database
+            Object.const_get("#{self.name}#{db.capitalize}").muliple_relations
+          end
+        end if database_list.any?
+      end
+    end
+  end
+
+
+  private
+
+  def run_setup
+    Object.class_eval do
+      def self.const_missing(c)
+        matches = []
+        db_matches = []
+        MultipleDbs::DBS.each do |db|
+          matches << c.to_s.scan(
+          Regexp.new('(([A-Z]){1}([a-zA-Z]|[0-9])*)+' + db.to_s.camelize + '$')
+          )
+          db_matches << db
+          break if matches.flatten.any?
+        end
+        const_temp = Object.const_get(matches.first).mdb(db_matches.last) if matches.flatten!.any?
+        MultipleDbs.validate_connection(db_matches.last) if matches.any? and const_temp.to_s.eql?(c.to_s)
+        return const_temp if matches.any? and const_temp.to_s.eql?(c.to_s)
+        super
+      end
+    end if Rails.env.development? and defined? MultipleDbs and defined? MultipleDbs::DBS
+
+    DBS.each do |db|
+      Object.const_set("DBConnection" + db.to_s.camelize , Class.new do
+        attr_accessor :connection
+        @connection = YAML::load(ERB.new(File.read(Rails.root.join("config/multiple_dbs", db.to_s.downcase  + "_database.yml"))).result)[Rails.env]
+        def self.connection
+          @connection
+        end
+      end)
+    end
+
+    DBS.each do |db|
+      conn_config = const_get("DBConnection" + db.to_s.camelize).connection
+      if conn_config["database"] != ActiveRecord::Base.connection_config[:database]
+        conn_klass = Object.const_set("Conn" + db.to_s.camelize, Class.new(ApplicationRecord))
+        conn_klass.establish_connection conn_config
+        conn_klass.connection
+      else
+        Object.const_set("Conn" + db.to_s.camelize, ActiveRecord::Base)
+      end
+    end
+
+    ActiveRecord::Base.clear_all_connections!
+  end
+  module_function :run_setup
+
+end
+
+# If running in development mode, rails use Kernel#load to load our code.
+# Is good, it allows us to make changes in files and see the changes in our
+# server/console instantly but the subclasses that we create for each one of
+# your models will not be available until you call the model...
+# So this piece of code override const_missing if you are running rails in
+# development and find the constants that you are looking for
+# (the multiple_dbs constants) behind the scenes

data/lib/multiple_dbs/railtie.rb

@@ -0,0 +1,9 @@
+module MultipleDbs
+  class Railtie < Rails::Railtie
+
+    rake_tasks do
+      load 'tasks/multiple_dbs_tasks.rake'
+    end
+
+  end
+end

data/lib/multiple_dbs/version.rb

@@ -0,0 +1,3 @@
+module MultipleDbs
+  VERSION = '1.0.0'
+end

data/lib/tasks/multiple_dbs_tasks.rake

@@ -0,0 +1,227 @@
+
+# Regexp used to find the databases list.
+REGEX_MATCH_FILES_BY_NAME = /config\/multiple_dbs\/([a-zA-Z]+[0-9]*|[0-9]+[a-zA-Z]*)_database.yml/
+
+# @dbs Store all the databases names
+@dbs = []
+
+# Search in the config/multiple_dbs directory and scan each filename looking for each database name
+Dir["config/multiple_dbs/*"].each do |file|
+  @dbs << file.scan(REGEX_MATCH_FILES_BY_NAME)
+end
+@dbs.flatten!
+
+
+# MultipleDbs namespace
+namespace :mdbs do
+  # Looping all the databases
+  @dbs.each do |db|
+    desc "databases managment #{db} tasks"
+    # A namespace per database
+    namespace db.to_sym do |database|
+      desc "#{db} drop"
+      task :drop do
+        Rake::Task["db:drop"].invoke
+      end
+      desc "#{db} create"
+      task :create do
+        Rake::Task["db:create"].invoke
+      end
+      desc "#{db} setup"
+      task :setup do
+        Rake::Task["db:setup"].invoke
+      end
+      desc "#{db} migrate"
+      task :migrate do
+        Rake::Task["db:migrate"].invoke
+      end
+      desc "#{db} rollback"
+      task :rollback do
+        Rake::Task["db:rollback"].invoke
+      end
+      desc "#{db} seed"
+      task :seed  do
+        Rake::Task["db:seed"].invoke
+      end
+      desc "#{db} version"
+      task :version do
+        Rake::Task["db:version"].invoke
+      end
+
+      namespace :schema do
+        desc "#{db} schema load"
+        task :load do
+          Rake::Task["db:schema:load"].invoke
+        end
+        desc "#{db} schema dump"
+        task :dump do
+          Rake::Task["db:schema:dump"].invoke
+        end
+      end
+
+      database.tasks.each do |task|
+        task.enhance ["mdbs:#{db}:set_custom_config"] do
+          Rake::Task["mdbs:#{db}:revert_to_original_config"].invoke
+        end
+      end
+
+      desc "#{db} set custom config"
+      task "set_custom_config".to_sym do
+        # save current vars
+        @original_config = {
+          env_schema: ENV['SCHEMA'],
+          config: Rails.application.config.dup
+        }
+        # set config variables for custom database
+        ENV['SCHEMA'] = "db/#{db}/schema.rb"
+        Rails.application.config.paths['db'] = ["db/#{db}"]
+        Rails.application.config.paths['db/migrate'] = ["db/#{db}/migrate"]
+        Rails.application.config.paths['db/seeds.rb'] = ["db/#{db}/seeds.rb"]
+        Rails.application.config.paths['config/database'] = ["config/multiple_dbs/#{db}_database.yml"]
+      end
+      desc "#{db} revert custom config"
+      task "revert_to_original_config".to_sym do
+        # reset config variables to original values
+        ENV['SCHEMA'] = @original_config[:env_schema]
+        Rails.application.config = @original_config[:config]
+      end
+    end #db tasks
+
+  end # looping dbes
+
+  desc "drop all dbs and delete their schema file"
+  task :hard_drop do
+    @dbs.each do |db|
+      puts "hard dropping #{db}"
+      puts system(" rake mdbs:#{db}:drop") ? "#{db} dropped" :  "Error while dropping #{db}"
+      puts system(" rm -rf db/#{db}/schema.rb ") ? "schema from #{db} removed" : "Error while erasing the schema from #{db}"
+    end
+  end
+
+  desc "drop, delete the schema files, create, migrate and seed for all dbs"
+  task :hard_reset do
+    @dbs.each do |db|
+      puts "hard reset #{db}"
+      puts system(" rake mdbs:#{db}:drop") ? "#{db} dropped" : "Error while dropping #{db}"
+      puts system(" rm -rf db/#{db}/schema.rb ") ? "schema from #{db} removed" : "Error while erasing the schema from #{db}"
+      puts system(" rake mdbs:#{db}:create") ? "#{db} created" : "Error while creating #{db}"
+      puts system(" rake mdbs:#{db}:migrate") ? "#{db} migrated" : "Error while migrating #{db}"
+      puts system(" rake mdbs:#{db}:seed") ? "#{db} seeded" : "Error while seeding #{db}"
+    end
+  end
+
+  desc "copy the seeds from the db/seed.rb file to each dbs seed file."
+  task :copy_seeds do
+    @dbs.each do |db|
+      puts "Copy seed to #{db}. #{system('cp db/seeds.rb db/#{db}/seeds.rb')}"
+    end
+  end
+
+  desc "copy the specified migration to each dbs migrations folder. Parameters: full_path.rb, database_name"
+  task :copy_migration, [:file_name, :db_name] do |t, args|
+    @dbs.each do |db|
+      puts "Copy migration from db/#{args[:db_name].downcase}/migrate/#{args[:file_name]} to db/#{db}/migrate/#{args[:file_name]}."
+      puts system("cp db/#{args[:db_name].downcase}/migrate/#{args[:file_name]} db/#{db}/migrate/#{args[:file_name]} ")
+    end
+  end
+
+  desc "copy the specified migration to the specified db migrations folder. Parameters: full_path.rb, from_database_name, to_database_name"
+  task :copy_migration_into, [:file_name, :from_database_name, :to_database_name] do |t, args|
+      puts "Copy migration from db/#{args[:from_database_name].downcase}/migrate/#{args[:file_name]} to db/#{args[:to_database_name]}/migrate/#{args[:file_name]}."
+      puts system("cp db/#{args[:from_database_name].downcase}/migrate/#{args[:file_name]} db/#{args[:to_database_name]}/migrate/#{args[:file_name]} ")
+  end
+
+  desc "copy the specified migration from the default migrations folder db/migrate to each dbs migrations folder. Parameters: full_path.rb"
+  task :copy_migration_from_default, [:file_name] do |t, args|
+    @dbs.each do |db|
+      puts "Copy migration from db/migrate/#{args[:file_name]} to db/#{db}/migrate/#{args[:file_name]}."
+      system(" mkdir db/#{db}")
+      system(" mkdir db/#{db}/migrate")
+      puts system("cp db/migrate/#{args[:file_name]} db/#{db}/migrate/#{args[:file_name]} ")
+    end
+  end
+
+  desc "copy the db/migration folder into each of your databases"
+  task :replicate_default_database do
+    @dbs.each do |db|
+      puts "Copy folder db/migrate to db/#{db}"
+      system(" mkdir db/#{db}")
+      puts system("cp -r db/migrate db/#{db}")
+    end
+  end
+
+  desc "copy the db/migration folder into the specified database"
+  task :replicate_default_database_into,[:db_name] do |t, args|
+      puts "Copy folder db/migrate to db/#{args[:db_name]}/migrate"
+      system(" mkdir db/#{args[:db_name]}")
+      puts system("cp -r db/migrate db/#{args[:db_name]}/migrate")
+  end
+
+  desc "copy the specified migration from the default migrations folder db/migrate, to the specified db migrations folder. Parameters: full_path.rb, to_database_name"
+  task :copy_migration_from_default_into, [:file_name, :to_database_name] do |t, args|
+      puts "Copy migration from db/migrate/#{args[:file_name]} to db/#{args[:to_database_name]}/migrate/#{args[:file_name]}."
+      system(" mkdir db/#{args[:to_database_name]}")
+      system(" mkdir db/#{args[:to_database_name]}/migrate")
+      puts system("cp db/migrate/#{args[:file_name]} db/#{args[:to_database_name]}/migrate/#{args[:file_name]} ")
+  end
+
+  desc "drop all dbs"
+  task :drop do
+      puts "Droping #{@dbs.join(',')}."
+      @dbs.each do |db|
+        Rake::Task["mdbs:#{db}:drop"].invoke
+        Rake::Task["db:drop"].reenable
+        Rake::Task["db:load_config"].reenable
+        Rake::Task["db:drop:_unsafe"].reenable
+        puts "#{db} dropped"
+      end
+  end
+  desc "create all dbs"
+  task :create do
+      @dbs.each do |db|
+        puts system(" rake mdbs:#{db}:create") ? "#{db} created" : "Error while creating #{db}"
+      end
+  end
+  desc "setup all dbs"
+  task :setup do
+      @dbs.each do |db|
+        puts system(" rake mdbs:#{db}:setup") ? "#{db} setup completed" : "Error while setting up #{db}"
+      end
+  end
+  desc "migrate all dbs"
+  task :migrate do
+      @dbs.each do |db|
+        puts system( "rake mdbs:#{db}:migrate" ) ? "#{db} migrated" : "Error while migrating #{db}"
+      end
+  end
+  desc "rollback all dbs"
+  task :rollback do
+      @dbs.each do |db|
+        puts system( "rake mdbs:#{db}:migrate" ) ? "#{db} rollback completed" : "Error while executing rollback on #{db}"
+      end
+  end
+  desc "seed all dbs"
+  task :seed do
+      @dbs.each do |db|
+        puts system( "rake mdbs:#{db}:seed" ) ? "#{db} seeded" : "Error while seeding #{db}"
+      end
+  end
+  desc "version all dbs"
+  task :version do
+      puts "Please use specific task for each database. Ex mdbs:my_db:version"
+  end
+  namespace :schema do
+    desc "schema load all dbs"
+    task :load do
+        @dbs.each do |db|
+          puts system(" rake mdbs:#{db}:schema:load ") ? "#{db} schema loaded" : "Error while loading schema for #{db}"
+        end
+    end
+    desc "schema dump all dbs"
+    task :dump do
+        @dbs.each do |db|
+          puts system(" rake mdbs:#{db}:schema:dump ") ? "#{db} schema dumped" : "Error while dumping schema for #{db}"
+        end
+    end
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: multiple_dbs
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yonga9121
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Management of multiple databases.
+email:
+- jorgeggayon@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/generators/multiple_dbs_initializer/USAGE
+- lib/generators/multiple_dbs_initializer/multiple_dbs_initializer_generator.rb
+- lib/generators/multiple_dbs_initializer/templates/config_db.yml
+- lib/generators/multiple_dbs_initializer/templates/initializer.rb
+- lib/generators/multiple_dbs_migration/USAGE
+- lib/generators/multiple_dbs_migration/multiple_dbs_migration_generator.rb
+- lib/generators/multiple_dbs_model/USAGE
+- lib/generators/multiple_dbs_model/multiple_dbs_model_generator.rb
+- lib/multiple_dbs.rb
+- lib/multiple_dbs/multi_connectable.rb
+- lib/multiple_dbs/railtie.rb
+- lib/multiple_dbs/version.rb
+- lib/tasks/multiple_dbs_tasks.rake
+homepage: https://yonga9121.github.io/multiple_dbs/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Management of multiple databases.
+test_files: []