pg_ha_migrations 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc85b0812b8317e3f129a5ee82749513549298437822ae30df47c80c1150dfd3
-  data.tar.gz: 88f379fb400d43d0fcf435646a6b102558d51909363a4daec4d519a865cac823
+  metadata.gz: 5b472247321efcc716bc1f7c4e497dcbe32058e4d2ce11d8f6d0d9fea7136755
+  data.tar.gz: 820bf96e3200deb2cffd30ba5534513600d05138f57f7812539cc8b33f96058a
 SHA512:
-  metadata.gz: 15e3cc9067bf0befe6b348fc1743e74d1c1511c26d089907054e427560db4eee05f4f82fc68c29e56165ee08416c7dfb195e94859539999fd9fd1474d23cc0bd
-  data.tar.gz: bcb14d8320a4aeb19617787076bcd01215c34e110a9e9d0562a24de87347958e86af2ee756a96d835e5f77844038a508bd76d9e623406ee5f8c3b3f4b49dfa5e
+  metadata.gz: b95318b6bf16ea1f5c9ec2514a6d6cccf912fc051caa9a954c58a038431d9afbbf01a23576f4ceaab1856922dc6e9aee5573743abb619f494c0f6023dcb217a9
+  data.tar.gz: 8bf47117312865cf57b51d200f3d131c266171a0f9899f39b8aa3f09aad50842555d93007a0b33a00873a7d67ec56a0f9b9027a028bf28338399939cd285ceda

data/.pryrc

@@ -0,0 +1,21 @@
+if defined?(PryByebug)
+  Pry.commands.alias_command 'c', 'continue'
+  Pry.commands.alias_command 's', 'step'
+  Pry.commands.alias_command 'n', 'next'
+  Pry.commands.alias_command 'f', 'finish'
+end
+
+# https://github.com/pry/pry/issues/1275#issuecomment-131969510
+# Prevent issue where text input does not display on screen in container after typing Ctrl-C in a pry repl
+at_exit do
+  exit!(1)
+end
+
+trap('INT') do
+  begin
+    Pry.run_command "continue", :show_output => true, :target => Pry.current
+  rescue
+    exit
+  end
+end
+# End pry Ctrl-C workaround

data/.travis.yml

@@ -6,4 +6,6 @@ services:
   - postgresql
 addons:
   postgresql: "9.6"
-before_install: gem install bundler -v 1.15.4
+before_install:
+  - gem uninstall -v '>= 2' -i $(rvm gemdir)@global -ax bundler || true
+  - gem install bundler -v 1.15.4

data/README.md

@@ -48,11 +48,25 @@ and never use `def change`. We believe that this is the only safe approach in pr
 
 ### Migrations
 
-In general, existing migrations are prefixed with `unsafe_` and safer alternatives are provided prefixed with `safe_`. 
+There are two major classes of concerns we try to handle in the API:
 
-Migrations prefixed with `unsafe_` will warn when invoked. The API is designed to be explicit yet remain flexible. There may be situations where invoking the unsafe migration is preferred.
+- Database safety (e.g., long-held locks)
+- Application safety (e.g., dropping columns the app uses)
 
-Migrations prefixed with `safe_` prefer concurrent operations where available, set low lock timeouts where appropriate, and decompose operations into multiple safe steps.
+We rename migration methods with prefixes denoting their safety level:
+
+- `safe_*`: These methods check for both application and database safety concerns prefer concurrent operations where available, set low lock timeouts where appropriate, and decompose operations into multiple safe steps.
+- `unsafe_*`: These methods are generally a direct dispatch to the native ActiveRecord migration method.
+
+Calling the original migration methods without a prefix will raise an error.
+
+The API is designed to be explicit yet remain flexible. There may be situations where invoking the `unsafe_*` method is preferred (or the only option available for definitionally unsafe operations).
+
+While `unsafe_*` methods were historically (through 1.0) pure wrappers for invoking the native ActiveRecord migration method, there is a class of problems that we can't handle easily without breaking that design rule a bit. For example, dropping a column is unsafe from an application perspective, so we make the application safety concerns explicit by using an `unsafe_` prefix. Using `unsafe_remove_column` calls out the need to audit the application to confirm the migration won't break the application. Because there are no safe alternatives we don't define a `safe_remove_column` analogue. However there are still conditions we'd like to assert before dropping a column. For example, dropping an unused column that's used in one or more indexes may be safe from an application perspective, but the cascading drop of the index won't use a `CONCURRENT` operation to drop the dependent indexes and is therefore unsafe from a database perspective.
+
+When `unsafe_*` migration methods support checks of this type you can bypass the checks by passing an `:allow_dependent_objects` key in the method's `options` hash containing an array of dependent object types you'd like to allow. Until 2.0 none of these checks will run by default, but you can opt-in by setting `config.check_for_dependent_objects = true` [in your configuration initializer](#configuration).
+
+Similarly we believe the `force: true` option to ActiveRecord's `create_table` method is always unsafe, and therefore we disallow it even when calling `unsafe_create_table`. This option won't be enabled by default until 2.0, but you can opt-in by setting `config.allow_force_create_table = false` [in your configuration initializer](#configuration).
 
 [Running multiple DDL statements inside a transaction acquires exclusive locks on all of the modified objects](https://medium.com/braintree-product-technology/postgresql-at-scale-database-schema-changes-without-downtime-20d3749ed680#cc22). For that reason, this gem [disables DDL transactions](./lib/pg_ha_migrations.rb:8) by default. You can change this by resetting `ActiveRecord::Migration.disable_ddl_transaction` in your application.
 
@@ -195,6 +209,20 @@ Set maintenance work mem.
 safe_set_maintenance_work_mem_gb 1
 ```
 
+### Configuration
+
+The gem can be configured in an initializer.
+
+```ruby
+PgHaMigrations.configure do |config|
+  # ...
+end
+```
+
+#### Available options
+
+- `disable_default_migration_methods`: If true, the default implementations of DDL changes in `ActiveRecord::Migration` and the PostgreSQL adapter will be overridden by implementations that raise a `PgHaMigrations::UnsafeMigrationError`. Default: `true`
+- `check_for_dependent_objects`: If true, some `unsafe_*` migration methods will raise a `PgHaMigrations::UnsafeMigrationError` if any dependent objects exist. Default: `false`
 
 ### Rake Tasks
 
@@ -220,6 +248,8 @@ Rake::Task["pg_ha_migrations:check_blocking_database_transactions"].enhance ["db
 
 After checking out the repo, run `bin/setup` to install dependencies and start a postgres docker container. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
+Running tests will automatically create a test database in the locally running Postgres server. You can find the connection parameters in `spec/spec_helper.rb`, but setting the environment variables `PGHOST`, `PGPORT`, `PGUSER`, and `PGPASSWORD` will override the defaults.
+
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing

data/lib/pg_ha_migrations/blocking_database_transactions_reporter.rb

@@ -29,9 +29,7 @@ module PgHaMigrations
                      migrations in this deploy that will attempt to create additional
                      concurrent indexes on the same physical database (even if the table
                      being indexes is on another dimension) those migrations will not be
-                     able to complete until the in-progress index creations finish.
-
-                     For more information, see #service-db in Slack.\n
+                     able to complete until the in-progress index creations finish.\n
           eos
           report << "\n" # Blank line intentional
         end

data/lib/pg_ha_migrations/dependent_objects_checks.rb

@@ -0,0 +1,61 @@
+module PgHaMigrations::DependentObjectsChecks
+  ALLOWED_TYPES_OPTIONS = [:indexes].freeze
+
+  ObjectDependency = Struct.new(:owner_type, :owner_name, :dependent_type, :dependent_name) do
+    def error_text
+      "#{dependent_type} '#{dependent_name}' depends on #{owner_type} '#{owner_name}'"
+    end
+  end
+
+  def dependent_objects_for_migration_method(method_name, arguments:)
+    allowed_types = arguments.last.is_a?(Hash) ? arguments.last[:allow_dependent_objects] || [] : []
+
+    if (invalid_allowed_types = allowed_types - ALLOWED_TYPES_OPTIONS).present?
+      raise ArgumentError, "Received invalid entries in allow_dependent_objects: #{invalid_allowed_types.inspect}"
+    end
+
+    dependent_objects = []
+
+    case method_name
+    when :remove_column
+      table_name = arguments[0]
+      column_name = arguments[1]
+
+      unless allowed_types.include?(:indexes)
+        # https://www.postgresql.org/docs/current/catalog-pg-depend.html
+        # deptype:
+        # - 'a' (DEPENDENCY_AUTO): the dependent object should be automatically
+        #   dropped if the referenced object is dropped
+        indexes = ActiveRecord::Base.structs_from_sql(ObjectDependency, <<~SQL)
+          SELECT
+            'column' AS owner_type,
+            ref_attr.attname AS owner_name,
+            'index' AS dependent_type,
+            dep_class.relname AS dependent_name
+          FROM pg_catalog.pg_depend
+          JOIN pg_catalog.pg_class ref_class ON ref_class.oid = pg_depend.refobjid
+          JOIN pg_catalog.pg_attribute ref_attr ON ref_attr.attrelid = ref_class.oid
+            AND ref_attr.attnum = pg_depend.refobjsubid
+          JOIN pg_catalog.pg_class dep_class ON dep_class.oid = pg_depend.objid
+          WHERE pg_depend.deptype = 'a'
+            AND pg_depend.refclassid = 'pg_class'::regclass
+            -- This doesn't currently handle table names that are duplicative across schemas.
+            AND ref_class.relname = '#{PG::Connection.escape_string(table_name.to_s)}'
+            AND ref_attr.attname = '#{PG::Connection.escape_string(column_name.to_s)}'
+            AND pg_depend.classid = 'pg_class'::regclass
+        SQL
+        dependent_objects.concat(indexes)
+      end
+    end
+  end
+
+  def disallow_migration_method_if_dependent_objects!(method_name, arguments:)
+    dependent_objects = dependent_objects_for_migration_method(method_name, arguments: arguments)
+
+    if dependent_objects.present?
+      raise PgHaMigrations::UnsafeMigrationError, dependent_objects.map(&:error_text).join("; ")
+    end
+  end
+end
+
+ActiveRecord::Migration.prepend(PgHaMigrations::DependentObjectsChecks)

data/lib/pg_ha_migrations/safe_statements.rb

@@ -1,5 +1,9 @@
 module PgHaMigrations::SafeStatements
   def safe_create_table(table, options={}, &block)
+    if options[:force]
+      raise PgHaMigrations::UnsafeMigrationError.new(":force is NOT SAFE! Explicitly call unsafe_drop_table first if you want to recreate an existing table")
+    end
+
     unsafe_create_table(table, options, &block)
   end
 
@@ -38,20 +42,17 @@ module PgHaMigrations::SafeStatements
     end
   end
 
-  def safe_change_column_default(table, column, default_value)
-    escaped_value = case default_value
-    when Proc
-      PG::Connection.escape_string(default_value.call.to_s)
-    else
-      "'#{PG::Connection.escape_string(default_value.to_s)}'"
+  def safe_change_column_default(table_name, column_name, default_value)
+    column = connection.send(:column_for, table_name, column_name)
+
+    if default_value.present? &&
+       !default_value.is_a?(Proc) &&
+       quote_default_expression(default_value, column) == "NULL"
+      raise PgHaMigrations::InvalidMigrationError, "Requested new default value of <#{default_value}>, but that casts to NULL for the type <#{column.type}>. Did you mean to you mean to use a Proc instead?"
     end
 
-    safely_acquire_lock_for_table(table) do
-      unsafe_execute <<-SQL.strip_heredoc
-        ALTER TABLE #{PG::Connection.quote_ident(table.to_s)}
-        ALTER COLUMN #{PG::Connection.quote_ident(column.to_s)}
-        SET DEFAULT #{escaped_value}
-      SQL
+    safely_acquire_lock_for_table(table_name) do
+      unsafe_change_column_default(table_name, column_name, default_value)
     end
   end
 

data/lib/pg_ha_migrations/unsafe_statements.rb

@@ -1,114 +1,110 @@
 module PgHaMigrations::UnsafeStatements
-  def self.delegate_unsafe_method_to_migration_base_class(method_name)
-    define_method("unsafe_#{method_name}") do |*args, &block|
-      # Dispatching here is a bit complicated: we need to execute the method
-      # belonging to the first member of the inheritance chain (besides
-      # UnsafeStatements). If don't find the method in the inheritance chain,
-      # we need to rely on the ActiveRecord::Migration#method_missing
-      # implementation since much of ActiveRecord::Migration's functionality
-      # is not implemented in real methods but rather by proxying.
-      #
-      # For example, ActiveRecord::Migration doesn't define #create_table.
-      # Instead ActiveRecord::Migration#method_missing proxies the method
-      # to the connection. However some migration compatibility version
-      # subclasses _do_ explicitly define #create_table, so we can't rely
-      # on only one way of finding the proper dispatch target.
-
-      # Exclude our `raise` guard implementations.
-      ancestors_without_unsafe_statements = self.class.ancestors - [PgHaMigrations::UnsafeStatements]
-
-      delegate_method = self.method(method_name)
-      candidate_method = delegate_method
-
-      # Find the first usable method in the ancestor chain
-      # or stop looking if there are no more possible
-      # implementations.
-      until candidate_method.nil? || ancestors_without_unsafe_statements.include?(candidate_method.owner)
-        candidate_method = candidate_method.super_method
+  def self.disable_or_delegate_default_method(method_name, error_message, allow_reentry_from_compatibility_module: false)
+    define_method(method_name) do |*args, &block|
+      if PgHaMigrations.config.check_for_dependent_objects
+        disallow_migration_method_if_dependent_objects!(method_name, arguments: args)
       end
 
-      if candidate_method
-        delegate_method = candidate_method
+      if PgHaMigrations.config.disable_default_migration_methods
+        # Most migration methods are only ever called by a migration and
+        # therefore aren't re-entrant or callable from another migration
+        # method, but `execute` is called directly by at least one of the
+        # implementations in `ActiveRecord::Migration::Compatibility` so
+        # we have to explicitly handle that case by allowing execution of
+        # the original implementation by its original name.
+        unless  allow_reentry_from_compatibility_module && caller[0] =~ /lib\/active_record\/migration\/compatibility.rb/
+          raise PgHaMigrations::UnsafeMigrationError, error_message
+        end
       end
 
-      # If we failed to find a concrete implementation from the
-      # inheritance chain, use ActiveRecord::Migrations# method_missing
-      # otherwise use the method from the inheritance chain.
-      if delegate_method.owner == PgHaMigrations::UnsafeStatements
-        method_missing(method_name, *args, &block)
-      else
-        delegate_method.call(*args, &block)
-      end
+      execute_ancestor_statement(method_name, *args, &block)
     end
   end
 
-  delegate_unsafe_method_to_migration_base_class :create_table
-  def create_table(name, options={})
-    raise PgHaMigrations::UnsafeMigrationError.new(":create_table is NOT SAFE! Use safe_create_table instead")
-  end
+  def self.delegate_unsafe_method_to_migration_base_class(method_name)
+    define_method("unsafe_#{method_name}") do |*args, &block|
+      if PgHaMigrations.config.check_for_dependent_objects
+        disallow_migration_method_if_dependent_objects!(method_name, arguments: args)
+      end
 
-  delegate_unsafe_method_to_migration_base_class :add_column
-  def add_column(table, column, type, options={})
-    raise PgHaMigrations::UnsafeMigrationError.new(":add_column is NOT SAFE! Use safe_add_column instead")
+      execute_ancestor_statement(method_name, *args, &block)
+    end
   end
 
+  delegate_unsafe_method_to_migration_base_class :add_column
   delegate_unsafe_method_to_migration_base_class :change_table
-  def change_table(name, options={})
-    raise PgHaMigrations::UnsafeMigrationError.new(":change_table is NOT SAFE! Use a combination of safe and explicit unsafe migration methods instead")
-  end
-
   delegate_unsafe_method_to_migration_base_class :drop_table
-  def drop_table(name)
-    raise PgHaMigrations::UnsafeMigrationError.new(":drop_table is NOT SAFE! Explicitly call :unsafe_drop_table to proceed")
-  end
-
   delegate_unsafe_method_to_migration_base_class :rename_table
-  def rename_table(old_name, new_name)
-    raise PgHaMigrations::UnsafeMigrationError.new(":rename_table is NOT SAFE! Explicitly call :unsafe_rename_table to proceed")
-  end
-
   delegate_unsafe_method_to_migration_base_class :rename_column
-  def rename_column(table_name, column_name, new_column_name)
-    raise PgHaMigrations::UnsafeMigrationError.new(":rename_column is NOT SAFE! Explicitly call :unsafe_rename_column to proceed")
-  end
-
   delegate_unsafe_method_to_migration_base_class :change_column
-  def change_column(table_name, column_name, type, options={})
-    raise PgHaMigrations::UnsafeMigrationError.new(":change_column is NOT SAFE! Use a combination of safe and explicit unsafe migration methods instead")
-  end
-
-  def change_column_null(table_name, column_name, null, default = nil)
-    raise PgHaMigrations::UnsafeMigrationError.new(<<-EOS.strip_heredoc)
-    :change_column_null is NOT (guaranteed to be) SAFE! Either use :safe_make_column_nullable or explicitly call :unsafe_make_column_not_nullable to proceed
-    EOS
-  end
-
+  delegate_unsafe_method_to_migration_base_class :change_column_default
   delegate_unsafe_method_to_migration_base_class :remove_column
-  def remove_column(table_name, column_name, type, options={})
-    raise PgHaMigrations::UnsafeMigrationError.new(":remove_column is NOT SAFE! Explicitly call :unsafe_remove_column to proceed")
-  end
-
   delegate_unsafe_method_to_migration_base_class :add_index
-  def add_index(table_name, column_names, options={})
-    raise PgHaMigrations::UnsafeMigrationError.new(":add_index is NOT SAFE! Use safe_add_concurrent_index instead")
-  end
-
   delegate_unsafe_method_to_migration_base_class :execute
-  def execute(sql, name = nil)
-    if caller[0] =~ /lib\/active_record\/migration\/compatibility.rb/
-      super
-    else
-      raise PgHaMigrations::UnsafeMigrationError.new(":execute is NOT SAFE! Explicitly call :unsafe_execute to proceed")
+  delegate_unsafe_method_to_migration_base_class :remove_index
+  delegate_unsafe_method_to_migration_base_class :add_foreign_key
+
+  disable_or_delegate_default_method :create_table, ":create_table is NOT SAFE! Use safe_create_table instead"
+  disable_or_delegate_default_method :add_column, ":add_column is NOT SAFE! Use safe_add_column instead"
+  disable_or_delegate_default_method :change_table, ":change_table is NOT SAFE! Use a combination of safe and explicit unsafe migration methods instead"
+  disable_or_delegate_default_method :drop_table, ":drop_table is NOT SAFE! Explicitly call :unsafe_drop_table to proceed"
+  disable_or_delegate_default_method :rename_table, ":rename_table is NOT SAFE! Explicitly call :unsafe_rename_table to proceed"
+  disable_or_delegate_default_method :rename_column, ":rename_column is NOT SAFE! Explicitly call :unsafe_rename_column to proceed"
+  disable_or_delegate_default_method :change_column, ":change_column is NOT SAFE! Use a combination of safe and explicit unsafe migration methods instead"
+  disable_or_delegate_default_method :change_column_default, ":change_column_default is NOT SAFE! Use safe_change_column_default instead"
+  disable_or_delegate_default_method :change_column_null, ":change_column_null is NOT (guaranteed to be) SAFE! Either use :safe_make_column_nullable or explicitly call :unsafe_make_column_not_nullable to proceed"
+  disable_or_delegate_default_method :remove_column, ":remove_column is NOT SAFE! Explicitly call :unsafe_remove_column to proceed"
+  disable_or_delegate_default_method :add_index, ":add_index is NOT SAFE! Use safe_add_concurrent_index instead"
+  disable_or_delegate_default_method :execute, ":execute is NOT SAFE! Explicitly call :unsafe_execute to proceed", allow_reentry_from_compatibility_module: true
+  disable_or_delegate_default_method :remove_index, ":remove_index is NOT SAFE! Use safe_remove_concurrent_index instead for Postgres 9.6 databases; Explicitly call :unsafe_remove_index to proceed on Postgres 9.1"
+  disable_or_delegate_default_method :add_foreign_key, ":add_foreign_key is NOT SAFE! Explicitly call :unsafe_add_foreign_key"
+
+  def unsafe_create_table(table, options={}, &block)
+    if options[:force] && !PgHaMigrations.config.allow_force_create_table
+      raise PgHaMigrations::UnsafeMigrationError.new(":force is NOT SAFE! Explicitly call unsafe_drop_table first if you want to recreate an existing table")
     end
-  end
 
-  delegate_unsafe_method_to_migration_base_class :remove_index
-  def remove_index(table_name, options={})
-    raise PgHaMigrations::UnsafeMigrationError.new(":remove_index is NOT SAFE! Use safe_remove_concurrent_index instead for Postgres 9.6 databases; Explicitly call :unsafe_remove_index to proceed on Postgres 9.1")
+    execute_ancestor_statement(:create_table, table, options, &block)
   end
 
-  delegate_unsafe_method_to_migration_base_class :add_foreign_key
-  def add_foreign_key(from_table, to_table, options)
-    raise PgHaMigrations::UnsafeMigrationError.new(":add_foreign_key is NOT SAFE! Explicitly call :unsafe_add_foreign_key only if you have guidance from a migration reviewer in #service-app-db.")
+  def execute_ancestor_statement(method_name, *args, &block)
+    # Dispatching here is a bit complicated: we need to execute the method
+    # belonging to the first member of the inheritance chain (besides
+    # UnsafeStatements). If don't find the method in the inheritance chain,
+    # we need to rely on the ActiveRecord::Migration#method_missing
+    # implementation since much of ActiveRecord::Migration's functionality
+    # is not implemented in real methods but rather by proxying.
+    #
+    # For example, ActiveRecord::Migration doesn't define #create_table.
+    # Instead ActiveRecord::Migration#method_missing proxies the method
+    # to the connection. However some migration compatibility version
+    # subclasses _do_ explicitly define #create_table, so we can't rely
+    # on only one way of finding the proper dispatch target.
+
+    # Exclude our `raise` guard implementations.
+    ancestors_without_unsafe_statements = self.class.ancestors - [PgHaMigrations::UnsafeStatements]
+
+    delegate_method = self.method(method_name)
+    candidate_method = delegate_method
+
+    # Find the first usable method in the ancestor chain
+    # or stop looking if there are no more possible
+    # implementations.
+    until candidate_method.nil? || ancestors_without_unsafe_statements.include?(candidate_method.owner)
+      candidate_method = candidate_method.super_method
+    end
+
+    if candidate_method
+      delegate_method = candidate_method
+    end
+
+    # If we failed to find a concrete implementation from the
+    # inheritance chain, use ActiveRecord::Migrations# method_missing
+    # otherwise use the method from the inheritance chain.
+    if delegate_method.owner == PgHaMigrations::UnsafeStatements
+      method_missing(method_name, *args, &block)
+    else
+      delegate_method.call(*args, &block)
+    end
   end
 end

data/lib/pg_ha_migrations/version.rb

@@ -1,3 +1,3 @@
 module PgHaMigrations
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/pg_ha_migrations.rb

@@ -5,6 +5,24 @@ require "active_record/migration"
 require "relation_to_struct"
 
 module PgHaMigrations
+  Config = Struct.new(
+    :disable_default_migration_methods,
+    :check_for_dependent_objects,
+    :allow_force_create_table
+  )
+
+  def self.config
+    @config ||= Config.new(
+      true,
+      false,
+      true
+    )
+  end
+
+  def self.configure
+    yield config
+  end
+
   LOCK_TIMEOUT_SECONDS = 5
   LOCK_FAILURE_RETRY_DELAY_MULTLIPLIER = 5
 
@@ -25,6 +43,7 @@ require "pg_ha_migrations/blocking_database_transactions"
 require "pg_ha_migrations/blocking_database_transactions_reporter"
 require "pg_ha_migrations/unsafe_statements"
 require "pg_ha_migrations/safe_statements"
+require "pg_ha_migrations/dependent_objects_checks"
 require "pg_ha_migrations/allowed_versions"
 require "pg_ha_migrations/railtie"
 require "pg_ha_migrations/hacks/disable_ddl_transaction"

data/pg_ha_migrations.gemspec

@@ -34,7 +34,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "pg"
   spec.add_development_dependency "db-query-matchers", "~> 0.9.0"
-
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-byebug'
 
   spec.add_dependency "rails", ">= 5.0", "< 5.3"
   spec.add_dependency "relation_to_struct"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_ha_migrations
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - celeen
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-04 00:00:00.000000000 Z
+date: 2019-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,6 +86,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  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'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -129,6 +157,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".pryrc"
 - ".rspec"
 - ".ruby-version"
 - ".travis.yml"
@@ -143,6 +172,7 @@ files:
 - lib/pg_ha_migrations/allowed_versions.rb
 - lib/pg_ha_migrations/blocking_database_transactions.rb
 - lib/pg_ha_migrations/blocking_database_transactions_reporter.rb
+- lib/pg_ha_migrations/dependent_objects_checks.rb
 - lib/pg_ha_migrations/hacks/disable_ddl_transaction.rb
 - lib/pg_ha_migrations/railtie.rb
 - lib/pg_ha_migrations/safe_statements.rb
@@ -169,8 +199,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Enforces DDL/migration safety in Ruby on Rails project with an emphasis on