activerecord-safer_migrations 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 75845456397be277043e0b89d6fedbac416d3fe3
+  data.tar.gz: 01add6f99123fd1bd0246f41504ec754d674dc87
+SHA512:
+  metadata.gz: b95179e85acb6a179fe9a05f018a4775fad27680bdb8f5945dbe43cc12187a53d91b13e4567097721df8ad5f14cdd465d68fb6aedc0896d86e19214e5b932d24
+  data.tar.gz: dbcd63bb99f1202a72d7a01b7857af9635bcce72d1c9703bedfa3035b607b9fcf2752bcb9953bba2b54412b0b46702f93a35c79355b7f78edf1d5729cd035148

data/.gitignore

@@ -0,0 +1 @@
+/.bundle

data/.rubocop.yml

@@ -0,0 +1,30 @@
+AllCops:
+  DisplayCopNames: true
+
+# Use trailing rather than leading dots on multi-line call chains
+Style/DotPosition:
+  EnforcedStyle: trailing
+
+Style/Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/TrailingComma:
+  EnforcedStyleForMultiline: comma
+
+Style/AccessorMethodName:
+  Enabled: false
+
+Style/SignalException:
+  EnforcedStyle: only_raise
+
+Style/GlobalVars:
+  Enabled: false
+
+Style/FileName:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 100

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p353

data/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+
+rvm:
+  - 2.2
+
+addons:
+  postgresql: "9.3"
+
+before_script:
+  - psql -c 'CREATE DATABASE safer_migrations_test;' -U postgres
+
+script:
+  - bundle exec rspec spec
+  - bundle exec rubocop
+
+env:
+  - "DATABASE_URL=postgres://postgres@localhost/safer_migrations_test"

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development do
+  gem "pg", "~> 0.18.3"
+  gem "rspec", "~> 3.3.0"
+  gem "rubocop", "~> 0.35.1"
+end

data/Gemfile.lock

@@ -0,0 +1,73 @@
+PATH
+  remote: .
+  specs:
+    activerecord-safer_migrations (0.1.0)
+      activerecord (~> 4.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.2.5)
+      activesupport (= 4.2.5)
+      builder (~> 3.1)
+    activerecord (4.2.5)
+      activemodel (= 4.2.5)
+      activesupport (= 4.2.5)
+      arel (~> 6.0)
+    activesupport (4.2.5)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    arel (6.0.3)
+    ast (2.1.0)
+    astrolabe (1.3.1)
+      parser (~> 2.2)
+    builder (3.2.2)
+    diff-lcs (1.2.5)
+    i18n (0.7.0)
+    json (1.8.3)
+    minitest (5.8.3)
+    parser (2.2.3.0)
+      ast (>= 1.1, < 3.0)
+    pg (0.18.3)
+    powerpack (0.1.1)
+    rainbow (2.0.0)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    rubocop (0.35.1)
+      astrolabe (~> 1.3)
+      parser (>= 2.2.3.0, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      tins (<= 1.6.0)
+    ruby-progressbar (1.7.5)
+    thread_safe (0.3.5)
+    tins (1.6.0)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord-safer_migrations!
+  pg (~> 0.18.3)
+  rspec (~> 3.3.0)
+  rubocop (~> 0.35.1)
+
+BUNDLED WITH
+   1.10.6

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 GoCardless Ltd.
+
+MIT License
+
+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,71 @@
+## ActiveRecord safer migration helpers
+
+*Note: this library only supports PostgreSQL 9.3+. If you're interested in adding support for other databases, we're open to pull requests!*
+
+Postgres holds ACCESS EXCLUSIVE locks for [almost all][pg-alter-table] DDL
+operations. ACCESS EXCLUSIVE locks conflict with all other table-level locks,
+which can cause issues in several situations. For instance:
+
+1. If the lock is held for a long time, all other access to the table will be
+   blocked, which can result in downtime.
+2. Even if the lock is only held breifly, it will block all other access to the
+   table while it is in the lock queue, as it conflicts with all other locks.
+   The lock can't be acquired until all other queries ahead of it have finished,
+   so having to wait on long-running queries can also result in downtime.
+   See [here][blog-post] for more details.
+
+Both these issues can be avoided by setting timeouts on the migration connection -
+`statement_timeout` and `lock_timeout` respectively.
+
+Once this gem is loaded, all migrations will automatically have a
+`lock_timeout` and a `statement_timeout` set. The initial `lock_timeout`
+default is 750ms, and the initial `statement_timeout` default is 1500ms. Both
+defaults can be easily changed (e.g. in a Rails initializer).
+
+```ruby
+ActiveRecord::SaferMigrations.default_lock_timeout = 1000
+ActiveRecord::SaferMigrations.default_statement_timeout = 2000
+```
+
+To explicitly set timeouts for a given migration, use the `set_lock_timeout` and
+`set_statement_timeout` class methods in the migration.
+
+```ruby
+class LockTest < ActiveRecord::Migration
+  set_lock_timeout(250)
+  set_statement_timeout(750)
+
+  def change
+    create_table :lock_test
+  end
+end
+```
+
+To disable timeouts for a migration, use the `disable_lock_timeout!` and
+`disable_statement_timeout!` class methods. Note that this is [extremely
+dangerous][blog-post] if you're doing any schema alterations in your migration.
+
+```ruby
+class LockTest < ActiveRecord::Migration
+  # Only do this if you really know what you're doing!
+  disable_lock_timeout!
+  disable_statement_timeout!
+
+  def change
+    create_table :lock_test
+  end
+end
+```
+
+### Use with PgBouncer
+
+This gem sets session-level settings on Postgres connections. If you're using
+PgBouncer in transaction pooling mode, using session-level settings is
+dangerous, as you can't guarantee which connection will receive the setting.
+For this reason, this gem is incompatible with transaction-pooling and should
+only be used if migrations are run on connections that support session-level
+features.
+
+[blog-post]: https://gocardless.com/blog/zero-downtime-postgres-migrations-the-hard-parts/
+[pg-alter-table]: http://www.postgresql.org/docs/9.4/static/sql-altertable.html
+

data/activerecord-safer_migrations.gemspec

@@ -0,0 +1,17 @@
+require File.expand_path("../lib/active_record/safer_migrations/version", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "activerecord-safer_migrations"
+  gem.version       = ActiveRecord::SaferMigrations::VERSION
+  gem.date          = "2015-08-10"
+  gem.summary       = "ActiveRecord migration helpers to avoid downtime"
+  gem.description   = ""
+  gem.authors       = ["GoCardless Engineering"]
+  gem.email         = "developers@gocardless.com"
+  gem.files         = `git ls-files`.split("\n")
+  gem.require_paths = ["lib"]
+  gem.homepage      = "https://github.com/gocardless/activerecord-safer_migrations"
+  gem.license       = "MIT"
+
+  gem.add_runtime_dependency "activerecord", "~> 4.2"
+end

data/lib/active_record/safer_migrations/migration.rb

@@ -0,0 +1,64 @@
+require "active_record/safer_migrations/setting_helper"
+
+module ActiveRecord
+  module SaferMigrations
+    module Migration
+      def self.included(base)
+        base.class_eval do
+          # Use Rails' class_attribute to get an attribute that you can
+          # override in subclasses
+          class_attribute :lock_timeout
+          class_attribute :statement_timeout
+
+          prepend(InstanceMethods)
+          extend(ClassMethods)
+        end
+      end
+
+      module InstanceMethods
+        def exec_migration(conn, direction)
+          # lock_timeout is an instance accessor created by class_attribute
+          lock_timeout_ms = lock_timeout || SaferMigrations.default_lock_timeout
+          statement_timeout_ms = statement_timeout || SaferMigrations.default_statement_timeout
+          SettingHelper.new(conn, :lock_timeout, lock_timeout_ms).with_setting do
+            SettingHelper.new(conn, :statement_timeout, statement_timeout_ms).with_setting do
+              super(conn, direction)
+            end
+          end
+        end
+      end
+
+      module ClassMethods
+        def set_lock_timeout(timeout)
+          if timeout == 0
+            raise "Setting lock_timeout to 0 is dangerous - it disables the lock " \
+                  "timeout rather than instantly timing out. If you *actually* " \
+                  "want to disable the lock timeout (not recommended!), use the " \
+                  "`disable_lock_timeout!` method."
+          end
+          self.lock_timeout = timeout
+        end
+
+        def disable_lock_timeout!
+          say "WARNING: disabling the lock timeout. This is very dangerous."
+          self.lock_timeout = 0
+        end
+
+        def set_statement_timeout(timeout)
+          if timeout == 0
+            raise "Setting statement_timeout to 0 is dangerous - it disables the statement " \
+                  "timeout rather than instantly timing out. If you *actually* " \
+                  "want to disable the statement timeout (not recommended!), use the " \
+                  "`disable_statement_timeout!` method."
+          end
+          self.statement_timeout = timeout
+        end
+
+        def disable_statement_timeout!
+          say "WARNING: disabling the statement timeout. This is very dangerous."
+          self.statement_timeout = 0
+        end
+      end
+    end
+  end
+end

data/lib/active_record/safer_migrations/postgresql_adapter.rb

@@ -0,0 +1,38 @@
+module ActiveRecord
+  module SaferMigrations
+    module PostgreSQLAdapter
+      SET_SETTING_SQL = <<-SQL
+      UPDATE
+        pg_settings
+      SET
+        setting = :value
+      WHERE
+        name = :setting_name
+      SQL
+
+      GET_SETTING_SQL = <<-SQL
+      SELECT
+        setting
+      FROM
+        pg_settings
+      WHERE
+        name = :setting_name
+      SQL
+
+      def set_setting(setting_name, value)
+        sql = fill_sql_values(SET_SETTING_SQL, value: value, setting_name: setting_name)
+        execute(sql)
+      end
+
+      def get_setting(setting_name)
+        sql = fill_sql_values(GET_SETTING_SQL, setting_name: setting_name)
+        result = execute(sql)
+        result.first["setting"]
+      end
+
+      def fill_sql_values(sql, values)
+        ActiveRecord::Base.send(:replace_named_bind_variables, sql, values)
+      end
+    end
+  end
+end

data/lib/active_record/safer_migrations/railtie.rb

@@ -0,0 +1,11 @@
+module ActiveRecord
+  module SaferMigrations
+    class Railtie < Rails::Railtie
+      initializer "active_record_safer_migrations.load_adapter" do
+        ActiveSupport.on_load :active_record do
+          ActiveRecord::SaferMigrations.load
+        end
+      end
+    end
+  end
+end

data/lib/active_record/safer_migrations/setting_helper.rb

@@ -0,0 +1,49 @@
+module ActiveRecord
+  module SaferMigrations
+    class SettingHelper
+      def initialize(connection, setting_name, value)
+        @connection = connection
+        @setting_name = setting_name
+        @value = value
+      end
+
+      # We're changing a connection level setting, and we need to make sure we return
+      # it to the original value. It is automatically reverted if set within a
+      # transaction which rolls back, so that case needs handling differently.
+      #
+      #                | In Transaction      | Not in transaction
+      # ---------------------------------------------------------
+      # Raises         | Reset setting       | Reset setting
+      # Doesn't raise  | Don't reset setting | Reset setting
+      def with_setting
+        record_current_setting
+        set_new_setting
+        yield
+        reset_setting
+      rescue
+        reset_setting unless in_transaction?
+        raise
+      end
+
+      private
+
+      def record_current_setting
+        @original_value = @connection.get_setting(@setting_name)
+      end
+
+      def set_new_setting
+        puts "-- set_setting(#{@setting_name.inspect}, #{@value})"
+        @connection.set_setting(@setting_name, @value)
+      end
+
+      def reset_setting
+        puts "-- set_setting(#{@setting_name.inspect}, #{@original_value})"
+        @connection.set_setting(@setting_name, @original_value)
+      end
+
+      def in_transaction?
+        ActiveRecord::Base.connection.open_transactions > 0
+      end
+    end
+  end
+end

data/lib/active_record/safer_migrations/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module SaferMigrations
+    VERSION = "0.1.0".freeze
+  end
+end

data/lib/activerecord-safer_migrations.rb

@@ -0,0 +1,38 @@
+require "active_record/connection_adapters/postgresql_adapter"
+require "active_record/safer_migrations/postgresql_adapter"
+require "active_record/safer_migrations/migration"
+
+module ActiveRecord
+  module SaferMigrations
+    @default_lock_timeout = 750
+    @default_statement_timeout = 1500
+
+    def self.default_lock_timeout
+      @default_lock_timeout
+    end
+
+    def self.default_lock_timeout=(timeout_ms)
+      @default_lock_timeout = timeout_ms
+    end
+
+    def self.default_statement_timeout
+      @default_statement_timeout
+    end
+
+    def self.default_statement_timeout=(timeout_ms)
+      @default_statement_timeout = timeout_ms
+    end
+
+    def self.load
+      ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+        include ActiveRecord::SaferMigrations::PostgreSQLAdapter
+      end
+
+      ActiveRecord::Migration.class_eval do
+        include ActiveRecord::SaferMigrations::Migration
+      end
+    end
+  end
+end
+
+require "active_record/safer_migrations/railtie" if defined?(::Rails)

data/spec/active_record/safer_migrations/migration_spec.rb

@@ -0,0 +1,160 @@
+require "spec_helper"
+
+RSpec.describe ActiveRecord::SaferMigrations::Migration do
+  before { nuke_migrations }
+  before { TimeoutTestHelpers.set(:lock_timeout, 0) }
+  before { TimeoutTestHelpers.set(:statement_timeout, 0) }
+
+  describe "setting timeouts explicitly" do
+    before { $lock_timeout = nil }
+    before { $statement_timeout = nil }
+
+    shared_examples_for "running the migration" do
+      let(:migration) do
+        Class.new(ActiveRecord::Migration) do
+          set_lock_timeout(5000)
+          set_statement_timeout(5001)
+
+          def change
+            $lock_timeout = TimeoutTestHelpers.get(:lock_timeout)
+            $statement_timeout = TimeoutTestHelpers.get(:statement_timeout)
+          end
+        end
+      end
+
+      it "sets the lock timeout for the duration of the migration" do
+        silence_stream($stdout) { run_migration.call }
+        expect($lock_timeout).to eq(5000)
+      end
+
+      it "unsets the lock timeout after the migration" do
+        silence_stream($stdout) { run_migration.call }
+        expect(TimeoutTestHelpers.get(:lock_timeout)).to eq(0)
+      end
+
+      it "sets the statement timeout for the duration of the migration" do
+        silence_stream($stdout) { run_migration.call }
+        expect($statement_timeout).to eq(5001)
+      end
+
+      it "unsets the statement timeout after the migration" do
+        silence_stream($stdout) { run_migration.call }
+        expect(TimeoutTestHelpers.get(:statement_timeout)).to eq(0)
+      end
+
+      context "when the original timeout is not 0" do
+        before { TimeoutTestHelpers.set(:lock_timeout, 8000) }
+        before { TimeoutTestHelpers.set(:statement_timeout, 8001) }
+
+        it "unsets the lock timeout after the migration" do
+          silence_stream($stdout) { run_migration.call }
+          expect(TimeoutTestHelpers.get(:lock_timeout)).to eq(8000)
+        end
+
+        it "unsets the statement timeout after the migration" do
+          silence_stream($stdout) { run_migration.call }
+          expect(TimeoutTestHelpers.get(:statement_timeout)).to eq(8001)
+        end
+      end
+    end
+
+    context "when running with transactional DDL" do
+      let(:run_migration) do
+        -> { ActiveRecord::Base.transaction { migration.migrate(:up) } }
+      end
+
+      include_examples "running the migration"
+    end
+
+    context "when running without transactional DDL" do
+      let(:run_migration) { -> { migration.migrate(:up) } }
+
+      include_examples "running the migration"
+    end
+  end
+
+  describe "the default timeouts" do
+    before { $lock_timeout = nil }
+    before { $statement_timeout = nil }
+    before { ActiveRecord::SaferMigrations.default_lock_timeout = 6000 }
+    before { ActiveRecord::SaferMigrations.default_statement_timeout = 6001 }
+    let(:migration) do
+      Class.new(ActiveRecord::Migration) do
+        def change
+          $lock_timeout = TimeoutTestHelpers.get(:lock_timeout)
+          $statement_timeout = TimeoutTestHelpers.get(:statement_timeout)
+        end
+      end
+    end
+
+    it "sets the lock timeout for the duration of the migration" do
+      silence_stream($stdout) { migration.migrate(:up) }
+      expect($lock_timeout).to eq(6000)
+    end
+
+    it "unsets the lock timeout after the migration" do
+      silence_stream($stdout) { migration.migrate(:up) }
+      expect(TimeoutTestHelpers.get(:lock_timeout)).to eq(0)
+    end
+
+    it "sets the statement timeout for the duration of the migration" do
+      silence_stream($stdout) { migration.migrate(:up) }
+      expect($statement_timeout).to eq(6001)
+    end
+
+    it "unsets the statement timeout after the migration" do
+      silence_stream($stdout) { migration.migrate(:up) }
+      expect(TimeoutTestHelpers.get(:statement_timeout)).to eq(0)
+    end
+  end
+
+  describe "when inheriting from a migration with timeouts defined" do
+    before { $lock_timeout = nil }
+    before { $statement_timeout = nil }
+    before { ActiveRecord::SaferMigrations.default_lock_timeout = 6000 }
+    before { ActiveRecord::SaferMigrations.default_statement_timeout = 6001 }
+    let(:base_migration) do
+      Class.new(ActiveRecord::Migration) do
+        set_lock_timeout(7000)
+        set_statement_timeout(7001)
+        def change
+          $lock_timeout = TimeoutTestHelpers.get(:lock_timeout)
+          $statement_timeout = TimeoutTestHelpers.get(:statement_timeout)
+        end
+      end
+    end
+
+    context "when the timeout isn't overridden" do
+      let(:migration) { Class.new(base_migration) {} }
+
+      it "sets the base class' lock timeout for the duration of the migration" do
+        silence_stream($stdout) { migration.migrate(:up) }
+        expect($lock_timeout).to eq(7000)
+      end
+
+      it "sets the base class' statement timeout for the duration of the migration" do
+        silence_stream($stdout) { migration.migrate(:up) }
+        expect($statement_timeout).to eq(7001)
+      end
+    end
+
+    context "when the timeout is overridden" do
+      let(:migration) do
+        Class.new(base_migration) do
+          set_lock_timeout(8000)
+          set_statement_timeout(8001)
+        end
+      end
+
+      it "sets the subclass' lock timeout for the duration of the migration" do
+        silence_stream($stdout) { migration.migrate(:up) }
+        expect($lock_timeout).to eq(8000)
+      end
+
+      it "sets the subclass' statement timeout for the duration of the migration" do
+        silence_stream($stdout) { migration.migrate(:up) }
+        expect($statement_timeout).to eq(8001)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require "active_record"
+require "activerecord-safer_migrations"
+
+ActiveRecord::SaferMigrations.load
+ActiveRecord::Base.establish_connection
+
+def silence_stream(stream)
+  old_stream = stream.dup
+  stream.reopen(IO::NULL)
+  stream.sync = true
+  yield
+ensure
+  stream.reopen(old_stream)
+  old_stream.close
+end
+
+def nuke_migrations
+  ActiveRecord::Base.connection_pool.with_connection do |conn|
+    conn.execute("DROP TABLE IF EXISTS schema_migrations")
+  end
+end
+
+module TimeoutTestHelpers
+  def self.get(timeout_name)
+    sql = <<-SQL
+    SELECT
+      setting AS #{timeout_name}
+    FROM
+      pg_settings
+    WHERE
+      name = '#{timeout_name}'
+    SQL
+    ActiveRecord::Base.connection.execute(sql).first[timeout_name.to_s].to_i
+  end
+
+  def self.set(timeout_name, timeout)
+    ActiveRecord::Base.connection.execute("SET #{timeout_name} = #{timeout}")
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-safer_migrations
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- GoCardless Engineering
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.2'
+description: ''
+email: developers@gocardless.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rubocop.yml
+- .ruby-version
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- activerecord-safer_migrations.gemspec
+- lib/active_record/safer_migrations/migration.rb
+- lib/active_record/safer_migrations/postgresql_adapter.rb
+- lib/active_record/safer_migrations/railtie.rb
+- lib/active_record/safer_migrations/setting_helper.rb
+- lib/active_record/safer_migrations/version.rb
+- lib/activerecord-safer_migrations.rb
+- spec/active_record/safer_migrations/migration_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/gocardless/activerecord-safer_migrations
+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.0.14
+signing_key: 
+specification_version: 4
+summary: ActiveRecord migration helpers to avoid downtime
+test_files: []