slavery 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d8d8a53892c3dc8ba6beea003eeb3e8dda2fcb7f
-  data.tar.gz: 884ce3b0bccb928742362447f0a1afdc9f7edc5c
+SHA256:
+  metadata.gz: f8332b57194b74343f78c15ecdebeb7e095399c83cd881d000e3f27006fbcd81
+  data.tar.gz: 2ce524c9a34355b9720d1d8fb428ae2715d2be8117d5c6c9327ac2c67c4c280f
 SHA512:
-  metadata.gz: 603d8b62b416668e3cec066d49308aa78f194557d14741e551f14280b337dcbc081e52cf48848141c1ab0a0ae8cdc948cc6ba1e85ddb177c2ad61d8a1357ffc3
-  data.tar.gz: b0fd5c1246b7ada095fa7a1ef93a88ef1cb6d134a6a4bf0e1b2f9ce9635a1b6a3dd729059729cc5ee10f442b491a7805aeacce26fe7c5b53110e73fc9d5bf243
+  metadata.gz: 25c186e7781354125ba4e8c141ffbc74820b11cc5da69cd83ba1e8aa80dd472575ba9646ce7cd9107f823cebd6d252bffebcb7bf95ba4520602da5383d3109f3
+  data.tar.gz: 02e38582bd24b63dbeada69fc22b3567539ad90c48841bdf2f1c0ed00812f97a6ae73aae58fb9ad9a00d0e974216851e59f60085743005d1ffe06362acf7c570

data/.gitignore

@@ -18,5 +18,5 @@ test/version_tmp
 tmp
 
 test_db
-test_slave_one
-test_slave_two
+test_standby_one
+test_standby_two

data/.travis.yml

@@ -1,13 +1,14 @@
 language: ruby
 
-rvm:
- - 2.2.2
- - 2.3.3
-
-gemfile:
-  - Gemfile
-  - gemfiles/rails3.2.gemfile
-  - gemfiles/rails4.gemfile
-  - gemfiles/rails4.2.gemfile
+matrix:
+  include:
+  - rvm: ruby-head
+    gemfile: Gemfile
+  - rvm: 2.5
+    gemfile: gemfiles/rails5.2.gemfile
+  - rvm: 2.5
+    gemfile: gemfiles/rails4.2.gemfile
+  - rvm: 2.2
+    gemfile: gemfiles/rails3.2.gemfile
 
 script: bundle exec rspec spec

data/Gemfile

@@ -1,3 +1,3 @@
 source 'https://rubygems.org'
 
-gemspec
+gemspec name: 'standby'

data/README.md

@@ -1,40 +1,40 @@
-# Slavery - Simple, conservative slave reads for ActiveRecord
+# Standby - Read from standby databases for ActiveRecord (formerly Slavery)
 
 [![Build Status](https://travis-ci.org/kenn/slavery.svg)](https://travis-ci.org/kenn/slavery)
 
-Slavery is a simple, easy to use gem for ActiveRecord that enables conservative slave reads, which means it doesn't automatically redirect all SELECTs to slaves.
+Standby is a simple, easy to use gem for ActiveRecord that enables conservative reading from standby databases, which means it won't automatically redirect all SELECTs to standbys.
 
-Instead, you can do `Slavery.on_slave { User.count }` to send a particular query to a slave.
+Instead, you can do `Standby.on_standby { User.count }` to send a particular query to a standby.
 
-Background: Probably your app started off with one single database. As it grows, you would upgrade to a master-slave replication for redundancy. At this point, all queries still go to the master and slaves are just backups. With that configuration, it's tempting to run some long-running queries on the slave. And that's exactly what Slavery does.
+Background: Probably your app started off with one single database. As it grows, you would upgrade to a primary-standby (or master-slave) replication for redundancy. At this point, all queries still go to the primary and standbys are just backups. With that configuration, it's tempting to run some long-running queries on one of the standbys. And that's exactly what Standby does.
 
-* Conservative - Safe by default. Installing Slavery won't change your app's current behavior.
+* Conservative - Safe by default. Installing Standby won't change your app's current behavior.
 * Future proof - No dirty hacks. Simply works as a proxy for `ActiveRecord::Base.connection`.
 * Simple code - Intentionally small. You can read the entire source and completely stay in control.
 
-Slavery works with ActiveRecord 3 or later.
+Standby works with ActiveRecord 3 or later.
 
 ## Install
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'slavery'
+gem 'standby'
 ```
 
-And create slave configs for each environment.
+And create standby configs for each environment.
 
 ```yaml
 development:
   database: myapp_development
 
-development_slave:
+development_standby:
   database: myapp_development
 ```
 
-By convention, config keys with `[env]_slave` are automatically used for slave reads.
+By convention, config keys with `[env]_standby` are automatically used for standby reads.
 
-Notice that we just copied the settings of `development` to `development_slave`. For `development` and `test`, it's actually recommended as probably you don't want to have replicating multiple databases on your machine. Two connections to the same identical database should be fine for testing purpose.
+Notice that we just copied the settings of `development` to `development_standby`. For `development` and `test`, it's actually recommended as probably you don't want to have replicating multiple databases on your machine. Two connections to the same identical database should be fine for testing purpose.
 
 In case you prefer DRYer definition, YAML's aliasing and key merging might help.
 
@@ -47,7 +47,7 @@ common: &common
 development:
   <<: *common
 
-development_slave:
+development_standby:
   <<: *common
 ```
 
@@ -55,46 +55,46 @@ Optionally, you can use a database url for your connections:
 
 ```yaml
 development: postgres://root:@localhost:5432/myapp_development
-development_slave: postgres://root:@localhost:5432/myapp_development_slave
+development_standby: postgres://root:@localhost:5432/myapp_development_standby
 ```
 
-At this point, Slavery does nothing. Run tests and confirm that nothing is broken.
+At this point, Standby does nothing. Run tests and confirm that nothing is broken.
 
 ## Usage
 
-To start using Slavery, you need to add `Slavery.on_slave` in your code. Queries in the `Slavery.on_slave` block run on the slave.
+To start using Standby, you need to add `Standby.on_standby` in your code. Queries in the `Standby.on_standby` block run on the standby.
 
 ```ruby
-Slavery.on_slave { User.count } 	# => runs on slave
-Slavery.on_slave(:two) { User.count }  # => runs on another slave configured as `development_slave_two`
+Standby.on_standby { User.count }   # => runs on standby
+Standby.on_standby(:two) { User.count }  # => runs on another standby configured as `development_standby_two`
 ```
 
-You can nest `on_slave` and `on_master` interchangeably. The following code works as expected.
+You can nest `on_standby` and `on_primary` interchangeably. The following code works as expected.
 
 ```ruby
-Slavery.on_slave do
+Standby.on_standby do
   ...
-  Slavery.on_master do
+  Standby.on_primary do
     ...
   end
   ...
 end
 ```
 
-Alternatively, you may call `on_slave` directly on the scope, so that the query will be read from slave when it's executed.
+Alternatively, you may call `on_standby` directly on the scope, so that the query will be read from standby when it's executed.
 
 ```ruby
-User.on_slave.where(active: true).count
+User.on_standby.where(active: true).count
 ```
 
-Caveat: `pluck` is not supported by the scope syntax, you still need `Slavery.on_slave` in this case.
+Caveat: `pluck` is not supported by the scope syntax, you still need `Standby.on_standby` in this case.
 
 ## Read-only user
 
-For an extra safeguard, it is recommended to use a read-only user for slave access.
+For an extra safeguard, it is recommended to use a read-only user for standby access.
 
 ```yaml
-development_slave:
+development_standby:
   <<: *common
   username: readonly
 ```
@@ -105,62 +105,85 @@ With MySQL, `GRANT SELECT` creates a read-only user.
 GRANT SELECT ON *.* TO 'readonly'@'localhost';
 ```
 
-With this user, writes on slave should raise an exception.
+With this user, writes on a standby should raise an exception.
 
 ```ruby
-Slavery.on_slave { User.create } 	# => ActiveRecord::StatementInvalid: Mysql2::Error: INSERT command denied...
+Standby.on_standby { User.create }  # => ActiveRecord::StatementInvalid: Mysql2::Error: INSERT command denied...
 ```
 
 With Postgres you can set the entire database to be readonly:
 
 ```SQL
-ALTER DATABASE myapp_development_slave SET default_transaction_read_only = true;
+ALTER DATABASE myapp_development_standby SET default_transaction_read_only = true;
 ```
 
 It is a good idea to confirm this behavior in your test code as well.
 
 ## Disable temporarily
 
-You can quickly disable slave reads by dropping the following line in `config/initializers/slavery.rb`.
+You can quickly disable standby reads by dropping the following line in `config/initializers/standby.rb`.
 
 ```ruby
-Slavery.disabled = true
+Standby.disabled = true
 ```
 
-With this line, Slavery stops connection switching and all queries go to the master.
+With this line, Standby stops connection switching and all queries go to the primary.
 
-This may be useful when one of the master or the slave goes down. You would rewrite `database.yml` to make all queries go to the surviving database, until you restore or rebuild the failed one.
+This may be useful when one of the primary or the standby goes down. You would rewrite `database.yml` to make all queries go to the surviving database, until you restore or rebuild the failed one.
 
 ## Transactional fixtures
 
 When `use_transactional_fixtures` is set to `true`, it's NOT recommended to
-write to the database besides fixtures, since the slave connection is not aware
-of changes performed in the master connection due to [transaction isolation](https://en.wikipedia.org/wiki/Isolation_(database_systems)).
+write to the database besides fixtures, since the standby connection is not aware
+of changes performed in the primary connection due to [transaction isolation](https://en.wikipedia.org/wiki/Isolation_(database_systems)).
 
-In that case, you are suggested to disable Slavery in the test environment by
+In that case, you are suggested to disable Standby in the test environment by
 putting the following in `test/test_helper.rb`
 (or `spec/spec_helper.rb` for RSpec users):
 
 ```ruby
-Slavery.disabled = true
+Standby.disabled = true
 ```
 
+## Upgrading from version 3 to version 4
+
+The gem name has been changed from `slavery` to `standby`.
+
+Update your Gemfile
+
+```ruby
+gem 'standby'
+```
+
+Replace `Slavery` with `Standby`, `on_slave` with `on_standby`, and `on_master` with `on_primary`.
+
+```sh
+grep -e Slavery **/*.rake **/*.rb -s -l | xargs sed -i "" "s|Slavery|Standby|g"
+grep -e on_slave **/*.rake **/*.rb -s -l | xargs sed -i "" "s|on_slave|on_standby|g"
+grep -e on_master **/*.rake **/*.rb -s -l | xargs sed -i "" "s|on_master|on_primary|g"
+```
+
+## Upgrading from version 2 to version 3
+
+Please note that `Standby.spec_key=` method has been removed from version 3.
+
 ## Support for non-Rails apps
 
 If you're using ActiveRecord in a non-Rails app (e.g. Sinatra), be sure to set `RACK_ENV` environment variable in the boot sequence, then:
 
 ```ruby
-require 'slavery'
+require 'standby'
 
 ActiveRecord::Base.configurations = {
-  'development' =>        { adapter: 'mysql2', ... },
-  'development_slave' =>  { adapter: 'mysql2', ... }
+  'development' =>          { adapter: 'mysql2', ... },
+  'development_standby' =>  { adapter: 'mysql2', ... }
 }
 ActiveRecord::Base.establish_connection(:development)
 ```
 
 ## Changelog
 
-* v3.0.0: Support for multiple slave targets ([@punchh](https://github.com/punchh))
+* v4.0.0: Rename gem from Slavery to Standby
+* v3.0.0: Support for multiple standby targets ([@punchh](https://github.com/punchh))
 * v2.1.0: Debug log support / Database URL support / Rails 3.2 & 4.0 compatibility (Thanks to [@citrus](https://github.com/citrus))
 * v2.0.0: Rails 5 support

data/Rakefile

@@ -1,4 +1,12 @@
-require 'bundler/gem_tasks'
+module Bundler
+  class GemHelper
+    def guard_clean
+      true
+    end
+  end
+end
+# require 'bundler/gem_tasks'
+Bundler::GemHelper.install_tasks(name: 'slavery')
 
 # RSpec
 require 'rspec/core/rake_task'

data/gemfiles/rails3.2.gemfile

@@ -6,4 +6,4 @@ group :development, :test do
   gem 'test-unit', '~> 3.0'
 end
 
-gemspec :path => '../'
+gemspec name: 'standby', path: '../'

data/gemfiles/rails4.2.gemfile

@@ -2,4 +2,4 @@ source "https://rubygems.org"
 
 gem 'activerecord', '~> 4.2'
 
-gemspec :path => '../'
+gemspec name: 'standby', path: '../'

data/gemfiles/rails5.2.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem 'activerecord', '~> 5.2'
+
+gemspec name: 'standby', path: '../'

data/lib/standby.rb

@@ -0,0 +1,29 @@
+require 'active_record'
+require 'standby/version'
+require 'standby/base'
+require 'standby/error'
+require 'standby/connection_holder'
+require 'standby/transaction'
+require 'standby/active_record/base'
+require 'standby/active_record/connection_handling'
+require 'standby/active_record/relation'
+require 'standby/active_record/log_subscriber'
+
+module Standby
+  class << self
+    attr_accessor :disabled
+
+    def standby_connections
+      @standby_connections ||= {}
+    end
+
+    def on_standby(name = :null_state, &block)
+      raise Standby::Error.new('invalid standby target') unless name.is_a?(Symbol)
+      Base.new(name).run &block
+    end
+
+    def on_primary(&block)
+      Base.new(:primary).run &block
+    end
+  end
+end

data/lib/standby/active_record/base.rb

@@ -0,0 +1,25 @@
+module ActiveRecord
+  class Base
+    class << self
+      alias_method :connection_without_standby, :connection
+
+      def connection
+        case Thread.current[:_standby]
+        when :primary, NilClass
+          connection_without_standby
+        else
+          Standby.connection_holder(Thread.current[:_standby]).connection_without_standby
+        end
+      end
+
+      # Generate scope at top level e.g. User.on_standby
+      def on_standby(name = :null_state)
+        # Why where(nil)?
+        # http://stackoverflow.com/questions/18198963/with-rails-4-model-scoped-is-deprecated-but-model-all-cant-replace-it
+        context = where(nil)
+        context.standby_target = name || :null_state
+        context
+      end
+    end
+  end
+end

data/lib/standby/active_record/log_subscriber.rb

@@ -0,0 +1,12 @@
+module ActiveRecord
+  class LogSubscriber
+
+    alias_method :debug_without_standby, :debug
+
+    def debug(msg)
+      db = Standby.disabled ? "" : color("[#{Thread.current[:_standby] || "primary"}]", ActiveSupport::LogSubscriber::GREEN, true)
+      debug_without_standby(db + msg)
+    end
+
+  end
+end

data/lib/standby/active_record/relation.rb

@@ -0,0 +1,28 @@
+module ActiveRecord
+  class Relation
+    attr_accessor :standby_target
+
+    # Supports queries like User.on_standby.to_a
+    alias_method :exec_queries_without_standby, :exec_queries
+
+    def exec_queries
+      if standby_target
+        Standby.on_standby(standby_target) { exec_queries_without_standby }
+      else
+        exec_queries_without_standby
+      end
+    end
+
+
+    # Supports queries like User.on_standby.count
+    alias_method :calculate_without_standby, :calculate
+
+    def calculate(*args)
+      if standby_target
+        Standby.on_standby(standby_target) { calculate_without_standby(*args) }
+      else
+        calculate_without_standby(*args)
+      end
+    end
+  end
+end

data/lib/standby/base.rb

@@ -0,0 +1,40 @@
+module Standby
+  class Base
+    def initialize(target)
+      @target = decide_with(target)
+    end
+
+    def run(&block)
+      run_on @target, &block
+    end
+
+  private
+
+    def decide_with(target)
+      if Standby.disabled || target == :primary
+        :primary
+      elsif inside_transaction?
+        raise Standby::Error.new('on_standby cannot be used inside transaction block!')
+      elsif target == :null_state
+        :standby
+      elsif target.present?
+        "standby_#{target}".to_sym
+      else
+        raise Standby::Error.new('on_standby cannot be used with a nil target!')
+      end
+    end
+
+    def inside_transaction?
+      open_transactions = run_on(:primary) { ActiveRecord::Base.connection.open_transactions }
+      open_transactions > Standby::Transaction.base_depth
+    end
+
+    def run_on(target)
+      backup = Thread.current[:_standby] # Save for recursive nested calls
+      Thread.current[:_standby] = target
+      yield
+    ensure
+      Thread.current[:_standby] = backup
+    end
+  end
+end

data/lib/{slavery → standby}/connection_holder.rb

@@ -1,4 +1,4 @@
-module Slavery
+module Standby
   class ConnectionHolder < ActiveRecord::Base
     self.abstract_class = true
 
@@ -6,7 +6,7 @@ module Slavery
       # for delayed activation
       def activate(target)
         spec = ActiveRecord::Base.configurations["#{ActiveRecord::ConnectionHandling::RAILS_ENV.call}_#{target}"]
-        raise Error.new("Slave target '#{target}' is invalid!") if spec.nil?
+        raise Error.new("Standby target '#{target}' is invalid!") if spec.nil?
         establish_connection spec
       end
     end
@@ -14,9 +14,9 @@ module Slavery
 
   class << self
     def connection_holder(target)
-      klass_name = "Slavery#{target.to_s.camelize}ConnectionHolder"
-      slave_connections[klass_name] ||= begin
-        klass = Class.new(Slavery::ConnectionHolder) do
+      klass_name = "Standby#{target.to_s.camelize}ConnectionHolder"
+      standby_connections[klass_name] ||= begin
+        klass = Class.new(Standby::ConnectionHolder) do
           self.abstract_class = true
         end
         Object.const_set(klass_name, klass)

data/lib/{slavery → standby}/error.rb

@@ -1,4 +1,4 @@
-module Slavery
+module Standby
   class Error < StandardError
   end
 end

data/lib/{slavery → standby}/transaction.rb

@@ -1,4 +1,4 @@
-module Slavery
+module Standby
   class Transaction
     # The methods on ActiveSupport::TestCase which can potentially be used
     # to determine if transactional fixtures are enabled

data/lib/standby/version.rb

@@ -0,0 +1,3 @@
+module Standby
+  VERSION = '4.0.0'
+end

data/slavery.gemspec

@@ -1,11 +1,14 @@
 # -*- encoding: utf-8 -*-
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'slavery/version'
+require 'standby/version'
 
 Gem::Specification.new do |gem|
+  gem.post_install_message = 'The slavery gem has been deprecated and has ' \
+                             'been replaced by standby. Please switch to ' \
+                             'standby as soon as possible.'
   gem.name          = 'slavery'
-  gem.version       = Slavery::VERSION
+  gem.version       = Standby::VERSION
   gem.authors       = ['Kenn Ejima']
   gem.email         = ['kenn.ejima@gmail.com']
   gem.description   = %q{Simple, conservative slave reads for ActiveRecord}
@@ -13,7 +16,7 @@ Gem::Specification.new do |gem|
   gem.homepage      = 'https://github.com/kenn/slavery'
 
   gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.executables   = gem.files.grep(%r{^exe/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ['lib']
 

data/spec/active_record/log_subscriber_spec.rb

@@ -10,30 +10,30 @@ describe ActiveRecord::LogSubscriber do
 
     before do
       ActiveRecord::Base.logger = logger
-      @backup_disabled = Slavery.disabled
+      @backup_disabled = Standby.disabled
     end
 
     after do
-      Slavery.disabled = @backup_disabled
+      Standby.disabled = @backup_disabled
     end
 
-    it 'it prefixes log messages with master' do
+    it 'it prefixes log messages with primary' do
       User.count
       log.rewind
-      expect(log.read).to include('[master]')
+      expect(log.read).to include('[primary]')
     end
 
-    it 'it prefixes log messages with the slave connection' do
-      User.on_slave.count
+    it 'it prefixes log messages with the standby connection' do
+      User.on_standby.count
       log.rewind
-      expect(log.read).to include('[slave]')
+      expect(log.read).to include('[standby]')
     end
 
-    it 'it does nothing when slavery is disabled' do
-      Slavery.disabled = true
+    it 'it does nothing when standby is disabled' do
+      Standby.disabled = true
       User.count
       log.rewind
-      expect(log.read).to_not include('[master]')
+      expect(log.read).to_not include('[primary]')
     end
 
   end

data/spec/configuration_spec.rb

@@ -3,32 +3,32 @@ require 'spec_helper'
 describe 'configuration' do
   before do
     # Backup connection and configs
-    @backup_conn = Slavery.instance_variable_get :@slave_connections
+    @backup_conn = Standby.instance_variable_get :@standby_connections
     @backup_config = ActiveRecord::Base.configurations.dup
-    @backup_disabled = Slavery.disabled
+    @backup_disabled = Standby.disabled
     @backup_conn.each_key do |klass_name|
       Object.send(:remove_const, klass_name) if Object.const_defined?(klass_name)
     end
-    Slavery.instance_variable_set :@slave_connections, {}
+    Standby.instance_variable_set :@standby_connections, {}
   end
 
   after do
     # Restore connection and configs
-    Slavery.instance_variable_set :@slave_connections, @backup_conn
+    Standby.instance_variable_set :@standby_connections, @backup_conn
     ActiveRecord::Base.configurations = @backup_config
-    Slavery.disabled = @backup_disabled
+    Standby.disabled = @backup_disabled
   end
 
-  it 'raises error if slave configuration not specified' do
-    ActiveRecord::Base.configurations['test_slave'] = nil
+  it 'raises error if standby configuration not specified' do
+    ActiveRecord::Base.configurations['test_standby'] = nil
 
-    expect { Slavery.on_slave { User.count } }.to raise_error(Slavery::Error)
+    expect { Standby.on_standby { User.count } }.to raise_error(Standby::Error)
   end
 
-  it 'connects to master if slave configuration is disabled' do
-    ActiveRecord::Base.configurations['test_slave'] = nil
-    Slavery.disabled = true
+  it 'connects to primary if standby configuration is disabled' do
+    ActiveRecord::Base.configurations['test_standby'] = nil
+    Standby.disabled = true
 
-    expect(Slavery.on_slave { User.count }).to be 2
+    expect(Standby.on_standby { User.count }).to be 2
   end
 end

data/spec/slavery_spec.rb

@@ -1,66 +1,66 @@
 require 'spec_helper'
 
-describe Slavery do
-  def slavery_value
-    Thread.current[:slavery]
+describe Standby do
+  def standby_value
+    Thread.current[:_standby]
   end
 
-  def on_slave?
-    slavery_value == :slave
+  def on_standby?
+    standby_value == :standby
   end
 
   it 'sets thread local' do
-    Slavery.on_master { expect(slavery_value).to be :master }
-    Slavery.on_slave  { expect(slavery_value).to be :slave }
-    Slavery.on_slave(:two) { expect(slavery_value).to be :slave_two}
+    Standby.on_primary { expect(standby_value).to be :primary }
+    Standby.on_standby { expect(standby_value).to be :standby }
+    Standby.on_standby(:two) { expect(standby_value).to be :standby_two}
   end
 
   it 'returns value from block' do
-    expect(Slavery.on_master { User.count }).to be 2
-    expect(Slavery.on_slave  { User.count }).to be 1
-    expect(Slavery.on_slave(:two) { User.count }).to be 0
+    expect(Standby.on_primary { User.count }).to be 2
+    expect(Standby.on_standby  { User.count }).to be 1
+    expect(Standby.on_standby(:two) { User.count }).to be 0
   end
 
   it 'handles nested calls' do
-    # Slave -> Slave
-    Slavery.on_slave do
-      expect(on_slave?).to be true
+    # Standby -> Standby
+    Standby.on_standby do
+      expect(on_standby?).to be true
 
-      Slavery.on_slave do
-        expect(on_slave?).to be true
+      Standby.on_standby do
+        expect(on_standby?).to be true
       end
 
-      expect(on_slave?).to be true
+      expect(on_standby?).to be true
     end
 
-    # Slave -> Master
-    Slavery.on_slave do
-      expect(on_slave?).to be true
+    # Standby -> Primary
+    Standby.on_standby do
+      expect(on_standby?).to be true
 
-      Slavery.on_master do
-        expect(on_slave?).to be false
+      Standby.on_primary do
+        expect(on_standby?).to be false
       end
 
-      expect(on_slave?).to be true
+      expect(on_standby?).to be true
     end
   end
 
   it 'raises error in transaction' do
     User.transaction do
-      expect { Slavery.on_slave { User.first } }.to raise_error(Slavery::Error)
+      expect { Standby.on_standby { User.first } }.to raise_error(Standby::Error)
     end
   end
 
   it 'disables by configuration' do
-    backup = Slavery.disabled
+    backup = Standby.disabled
 
-    Slavery.disabled = false
-    Slavery.on_slave { expect(slavery_value).to be :slave }
+    Standby.disabled = false
+    Standby.on_standby { expect(standby_value).to be :standby }
 
-    Slavery.disabled = true
-    Slavery.on_slave { expect(slavery_value).to be :master }
+    Standby.disabled = true
+    Standby.on_standby { expect(standby_value).to be :primary }
 
-    Slavery.disabled = backup
+    Standby.disabled = backup
   end
 
   it 'avoids stack overflow with 3rdparty gem that defines alias_method. namely newrelic...' do
@@ -79,29 +79,29 @@ describe Slavery do
     end
   end
 
-  it 'works with nils like slave' do
-    expect(User.on_slave(nil).count).to be User.on_slave.count
+  it 'works with nils like standby' do
+    expect(User.on_standby(nil).count).to be User.on_standby.count
   end
 
   it 'raises on blanks and strings' do
-    expect { User.on_slave("").count }.to raise_error(Slavery::Error)
-    expect { User.on_slave("two").count }.to raise_error(Slavery::Error)
-    expect { User.on_slave("slave").count }.to raise_error(Slavery::Error)
+    expect { User.on_standby("").count }.to raise_error(Standby::Error)
+    expect { User.on_standby("two").count }.to raise_error(Standby::Error)
+    expect { User.on_standby("standby").count }.to raise_error(Standby::Error)
   end
 
   it 'raises with non existent extension' do
-    expect { Slavery.on_slave(:non_existent) { User.first } }.to raise_error(Slavery::Error)
+    expect { Standby.on_standby(:non_existent) { User.first } }.to raise_error(Standby::Error)
   end
 
   it 'works with any scopes' do
     expect(User.count).to be 2
-    expect(User.on_slave(:two).count).to be 0
-    expect(User.on_slave.count).to be 1
+    expect(User.on_standby(:two).count).to be 0
+    expect(User.on_standby.count).to be 1
 
     # Why where(nil)?
     # http://stackoverflow.com/questions/18198963/with-rails-4-model-scoped-is-deprecated-but-model-all-cant-replace-it
     expect(User.where(nil).to_a.size).to be 2
-    expect(User.on_slave(:two).where(nil).to_a.size).to be 0
-    expect(User.on_slave.where(nil).to_a.size).to be 1
+    expect(User.on_standby(:two).where(nil).to_a.size).to be 0
+    expect(User.on_standby.where(nil).to_a.size).to be 1
   end
 end

data/spec/spec_helper.rb

@@ -3,13 +3,13 @@ require 'bundler/setup'
 
 ENV['RACK_ENV'] = 'test'
 
-require 'slavery'
+require 'standby'
 
 ActiveRecord::Base.configurations = {
   'test'            =>  { 'adapter' => 'sqlite3', 'database' => 'test_db' },
-  'test_slave'      =>  { 'adapter' => 'sqlite3', 'database' => 'test_slave_one' },
-  'test_slave_two'  =>  { 'adapter' => 'sqlite3', 'database' => 'test_slave_two'},
-  'test_slave_url'  =>  'postgres://root:@localhost:5432/test_slave'
+  'test_standby'      =>  { 'adapter' => 'sqlite3', 'database' => 'test_standby_one' },
+  'test_standby_two'  =>  { 'adapter' => 'sqlite3', 'database' => 'test_standby_two'},
+  'test_standby_url'  =>  'postgres://root:@localhost:5432/test_standby'
 }
 
 # Prepare databases
@@ -23,23 +23,23 @@ end
 
 class Seeder
   def run
-    # Populate on master
+    # Populate on primary
     connect(:test)
     create_tables
     User.create
     User.create
     User.first.items.create
 
-    # Populate on slave, emulating replication lag
-    connect(:test_slave)
+    # Populate on standby, emulating replication lag
+    connect(:test_standby)
     create_tables
     User.create
 
-    # Populate on slave two
-    connect(:test_slave_two)
+    # Populate on standby two
+    connect(:test_standby_two)
     create_tables
 
-    # Reconnect to master
+    # Reconnect to primary
     connect(:test)
   end
 

data/standby.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'standby/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'standby'
+  gem.version       = Standby::VERSION
+  gem.authors       = ['Kenn Ejima']
+  gem.email         = ['kenn.ejima@gmail.com']
+  gem.description   = %q{Read from stand-by databases for ActiveRecord}
+  gem.summary       = %q{Read from stand-by databases for ActiveRecord}
+  gem.homepage      = 'https://github.com/kenn/standby'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^exe/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_runtime_dependency 'activerecord', '>= 3.0.0'
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'sqlite3'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slavery
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Kenn Ejima
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-18 00:00:00.000000000 Z
+date: 2018-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -55,8 +55,7 @@ dependencies:
 description: Simple, conservative slave reads for ActiveRecord
 email:
 - kenn.ejima@gmail.com
-executables:
-- console
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -70,26 +69,28 @@ files:
 - bin/console
 - gemfiles/rails3.2.gemfile
 - gemfiles/rails4.2.gemfile
-- gemfiles/rails4.gemfile
-- lib/slavery.rb
-- lib/slavery/active_record/base.rb
-- lib/slavery/active_record/connection_handling.rb
-- lib/slavery/active_record/log_subscriber.rb
-- lib/slavery/active_record/relation.rb
-- lib/slavery/base.rb
-- lib/slavery/connection_holder.rb
-- lib/slavery/error.rb
-- lib/slavery/transaction.rb
-- lib/slavery/version.rb
+- gemfiles/rails5.2.gemfile
+- lib/standby.rb
+- lib/standby/active_record/base.rb
+- lib/standby/active_record/connection_handling.rb
+- lib/standby/active_record/log_subscriber.rb
+- lib/standby/active_record/relation.rb
+- lib/standby/base.rb
+- lib/standby/connection_holder.rb
+- lib/standby/error.rb
+- lib/standby/transaction.rb
+- lib/standby/version.rb
 - slavery.gemspec
 - spec/active_record/log_subscriber_spec.rb
 - spec/configuration_spec.rb
 - spec/slavery_spec.rb
 - spec/spec_helper.rb
+- standby.gemspec
 homepage: https://github.com/kenn/slavery
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message: The slavery gem has been deprecated and has been replaced by
+  standby. Please switch to standby as soon as possible.
 rdoc_options: []
 require_paths:
 - lib
@@ -105,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Simple, conservative slave reads for ActiveRecord

data/gemfiles/rails4.gemfile

@@ -1,5 +0,0 @@
-source "https://rubygems.org"
-
-gem 'activerecord', '~> 4.0.0'
-
-gemspec :path => '../'

data/lib/slavery.rb

@@ -1,29 +0,0 @@
-require 'active_record'
-require 'slavery/version'
-require 'slavery/base'
-require 'slavery/error'
-require 'slavery/connection_holder'
-require 'slavery/transaction'
-require 'slavery/active_record/base'
-require 'slavery/active_record/connection_handling'
-require 'slavery/active_record/relation'
-require 'slavery/active_record/log_subscriber'
-
-module Slavery
-  class << self
-    attr_accessor :disabled
-
-    def slave_connections
-      @slave_connections ||= {}
-    end
-
-    def on_slave(name = :null_state, &block)
-      raise Slavery::Error.new('invalid slave target') unless name.is_a?(Symbol)
-      Base.new(name).run &block
-    end
-
-    def on_master(&block)
-      Base.new(:master).run &block
-    end
-  end
-end

data/lib/slavery/active_record/base.rb

@@ -1,25 +0,0 @@
-module ActiveRecord
-  class Base
-    class << self
-      alias_method :connection_without_slavery, :connection
-
-      def connection
-        case Thread.current[:slavery]
-        when :master, NilClass
-          connection_without_slavery
-        else
-          Slavery.connection_holder(Thread.current[:slavery]).connection_without_slavery
-        end
-      end
-
-      # Generate scope at top level e.g. User.on_slave
-      def on_slave(name = :null_state)
-        # Why where(nil)?
-        # http://stackoverflow.com/questions/18198963/with-rails-4-model-scoped-is-deprecated-but-model-all-cant-replace-it
-        context = where(nil)
-        context.slavery_target = name || :null_state
-        context
-      end
-    end
-  end
-end

data/lib/slavery/active_record/log_subscriber.rb

@@ -1,12 +0,0 @@
-module ActiveRecord
-  class LogSubscriber
-
-    alias_method :debug_without_slavery, :debug
-
-    def debug(msg)
-      db = Slavery.disabled ? "" : color("[#{Thread.current[:slavery] || "master"}]", ActiveSupport::LogSubscriber::GREEN, true)
-      debug_without_slavery(db + msg)
-    end
-
-  end
-end

data/lib/slavery/active_record/relation.rb

@@ -1,28 +0,0 @@
-module ActiveRecord
-  class Relation
-    attr_accessor :slavery_target
-
-    # Supports queries like User.on_slave.to_a
-    alias_method :exec_queries_without_slavery, :exec_queries
-
-    def exec_queries
-      if slavery_target
-        Slavery.on_slave(slavery_target) { exec_queries_without_slavery }
-      else
-        exec_queries_without_slavery
-      end
-    end
-
-
-    # Supports queries like User.on_slave.count
-    alias_method :calculate_without_slavery, :calculate
-
-    def calculate(*args)
-      if slavery_target
-        Slavery.on_slave(slavery_target) { calculate_without_slavery(*args) }
-      else
-        calculate_without_slavery(*args)
-      end
-    end
-  end
-end

data/lib/slavery/base.rb

@@ -1,40 +0,0 @@
-module Slavery
-  class Base
-    def initialize(target)
-      @target = decide_with(target)
-    end
-
-    def run(&block)
-      run_on @target, &block
-    end
-
-  private
-
-    def decide_with(target)
-      if Slavery.disabled || target == :master
-        :master
-      elsif inside_transaction?
-        raise Slavery::Error.new('on_slave cannot be used inside transaction block!')
-      elsif target == :null_state
-        :slave
-      elsif target.present?
-        "slave_#{target}".to_sym
-      else
-        raise Slavery::Error.new('on_slave cannot be used with a nil target!')
-      end
-    end
-
-    def inside_transaction?
-      open_transactions = run_on(:master) { ActiveRecord::Base.connection.open_transactions }
-      open_transactions > Slavery::Transaction.base_depth
-    end
-
-    def run_on(target)
-      backup = Thread.current[:slavery] # Save for recursive nested calls
-      Thread.current[:slavery] = target
-      yield
-    ensure
-      Thread.current[:slavery] = backup
-    end
-  end
-end

data/lib/slavery/version.rb

@@ -1,3 +0,0 @@
-module Slavery
-  VERSION = '3.0.0'
-end