strong_migrations 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bce49483e36caa343a3496771d052e4cc7d4db1e72c0ca23d80be1339bcb4dae
-  data.tar.gz: e15a13f2c41a610c8a6825a209581b2b66d28584ecc41fcc6c46f2f0d69ff293
+  metadata.gz: a77b960928e0167e1842dbd337dc0e47ecae009fec7e6b13cdfba539cb2addc5
+  data.tar.gz: 154e03c69d7790a81051bf55b0d2a04a0a1ce0ed83d347f5a44f7255f950f794
 SHA512:
-  metadata.gz: 68f4b5e294502c361c23cf17bf921310a285b27b4f5112c115ac26683af0f3841bf2815229bf793feab85ae71cac93e3e4e76f6928aa47cfe913669d2c3219ce
-  data.tar.gz: 2dc364a36b8aa88408554a5671d8380cc6d27ab17321542181cebac3568cc5bcc4ea61d14508e6c59a9641e41e074ee0120d7f4098648c1f6508be1d479289c5
+  metadata.gz: 90839d0e1af71af600a220dd689262c6472190d437a61e97da40bd79c7ec5f4d418d45c2b3ff88514e3ab1ceca8cc04bb912f1f3e6553ba3efac53eb6d171992
+  data.tar.gz: bbf6f7b9645391d8fdaa54b8edf59904d2f75c806bcd7d0940eb762cc102c2355fafa231114d20a1cb8cae603eea807fd654868da3f6f40846a8fe022bd58778

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.4.2
+
+- Allow `add_reference` with concurrent indexes
+
 ## 0.4.1
 
 - Added `target_postgresql_version`

data/README.md

@@ -50,7 +50,7 @@ Also checks for best practices:
 ActiveRecord caches database columns at runtime, so if you drop a column, it can cause exceptions until your app reboots.
 
 ```ruby
-class RemoveSomeColumnFromUsers < ActiveRecord::Migration[5.2]
+class RemoveSomeColumnFromUsers < ActiveRecord::Migration[6.0]
   def change
     remove_column :users, :some_column
   end
@@ -71,7 +71,7 @@ end
 3. Write a migration to remove the column (wrap in `safety_assured` block)
 
   ```ruby
-  class RemoveSomeColumnFromUsers < ActiveRecord::Migration[5.2]
+  class RemoveSomeColumnFromUsers < ActiveRecord::Migration[6.0]
     def change
       safety_assured { remove_column :users, :some_column }
     end
@@ -87,7 +87,7 @@ end
 Adding a column with a default value to an existing table causes the entire table to be rewritten.
 
 ```ruby
-class AddSomeColumnToUsers < ActiveRecord::Migration[5.2]
+class AddSomeColumnToUsers < ActiveRecord::Migration[6.0]
   def change
     add_column :users, :some_column, :text, default: "default_value"
   end
@@ -101,7 +101,7 @@ end
 Instead, add the column without a default value, then change the default.
 
 ```ruby
-class AddSomeColumnToUsers < ActiveRecord::Migration[5.2]
+class AddSomeColumnToUsers < ActiveRecord::Migration[6.0]
   def up
     add_column :users, :some_column, :text
     change_column_default :users, :some_column, "default_value"
@@ -122,7 +122,7 @@ See the next section for how to backfill.
 Backfilling in the same transaction that alters a table locks the table for the [duration of the backfill](https://wework.github.io/data/2015/11/05/add-columns-with-default-values-to-large-tables-in-rails-postgres/).
 
 ```ruby
-class AddSomeColumnToUsers < ActiveRecord::Migration[5.2]
+class AddSomeColumnToUsers < ActiveRecord::Migration[6.0]
   def change
     add_column :users, :some_column, :text
     User.update_all some_column: "default_value"
@@ -134,10 +134,10 @@ Also, running a single query to update data can cause issues for large tables.
 
 #### Good
 
-There are three keys: batching, throttling, and running it outside a transaction. Use the Rails console or a separate migration with `disable_ddl_transaction!`.
+There are three keys to backfilling safely: batching, throttling, and running it outside a transaction. Use the Rails console or a separate migration with `disable_ddl_transaction!`.
 
 ```ruby
-class BackfillSomeColumn < ActiveRecord::Migration[5.2]
+class BackfillSomeColumn < ActiveRecord::Migration[6.0]
   disable_ddl_transaction!
 
   def change
@@ -156,7 +156,7 @@ end
 In Postgres, adding a non-concurrent index locks the table.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[5.2]
+class AddSomeIndexToUsers < ActiveRecord::Migration[6.0]
   def change
     add_index :users, :some_column
   end
@@ -168,7 +168,7 @@ end
 Add indexes concurrently.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[5.2]
+class AddSomeIndexToUsers < ActiveRecord::Migration[6.0]
   disable_ddl_transaction!
 
   def change
@@ -186,7 +186,7 @@ If you forget `disable_ddl_transaction!`, the migration will fail. Also, note th
 Rails adds a non-concurrent index to references by default, which is problematic for Postgres.
 
 ```ruby
-class AddReferenceToUsers < ActiveRecord::Migration[5.2]
+class AddReferenceToUsers < ActiveRecord::Migration[6.0]
   def change
     add_reference :users, :city
   end
@@ -198,12 +198,11 @@ end
 Make sure the index is added concurrently.
 
 ```ruby
-class AddReferenceToUsers < ActiveRecord::Migration[5.2]
+class AddReferenceToUsers < ActiveRecord::Migration[6.0]
   disable_ddl_transaction!
 
   def change
-    add_reference :users, :city, index: false
-    add_index :users, :city_id, algorithm: :concurrently
+    add_reference :users, :city, index: {algorithm: :concurrently}
   end
 end
 ```
@@ -217,7 +216,7 @@ For polymorphic references, add a compound index on type and id.
 In Postgres, new foreign keys are validated by default, which acquires an `AccessExclusiveLock` that can be [expensive on large tables](https://travisofthenorth.com/blog/2017/2/2/postgres-adding-foreign-keys-with-zero-downtime).
 
 ```ruby
-class AddForeignKeyOnUsers < ActiveRecord::Migration[5.2]
+class AddForeignKeyOnUsers < ActiveRecord::Migration[6.0]
   def change
     add_foreign_key :users, :orders
   end
@@ -231,7 +230,7 @@ Instead, validate it in a separate migration with a more agreeable `RowShareLock
 For Rails 5.2+, use:
 
 ```ruby
-class AddForeignKeyOnUsers < ActiveRecord::Migration[5.2]
+class AddForeignKeyOnUsers < ActiveRecord::Migration[6.0]
   def change
     add_foreign_key :users, :orders, validate: false
   end
@@ -241,7 +240,7 @@ end
 Then validate it in a separate migration.
 
 ```ruby
-class ValidateForeignKeyOnUsers < ActiveRecord::Migration[5.2]
+class ValidateForeignKeyOnUsers < ActiveRecord::Migration[6.0]
   def change
     validate_foreign_key :users, :orders
   end
@@ -277,7 +276,7 @@ end
 #### Bad
 
 ```ruby
-class RenameSomeColumn < ActiveRecord::Migration[5.2]
+class RenameSomeColumn < ActiveRecord::Migration[6.0]
   def change
     rename_column :users, :some_column, :new_name
   end
@@ -287,7 +286,7 @@ end
 or
 
 ```ruby
-class ChangeSomeColumnType < ActiveRecord::Migration[5.2]
+class ChangeSomeColumnType < ActiveRecord::Migration[6.0]
   def change
     change_column :users, :some_column, :new_type
   end
@@ -312,7 +311,7 @@ A safer approach is to:
 #### Bad
 
 ```ruby
-class RenameUsersToCustomers < ActiveRecord::Migration[5.2]
+class RenameUsersToCustomers < ActiveRecord::Migration[6.0]
   def change
     rename_table :users, :customers
   end
@@ -337,7 +336,7 @@ A safer approach is to:
 The `force` option can drop an existing table.
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[5.2]
+class CreateUsers < ActiveRecord::Migration[6.0]
   def change
     create_table :users, force: true do |t|
       # ...
@@ -348,10 +347,10 @@ end
 
 #### Good
 
-If you intend to drop a table, do it explicitly. Then create the new table without the `force` option:
+Create tables without the `force` option.
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[5.2]
+class CreateUsers < ActiveRecord::Migration[6.0]
   def change
     create_table :users do |t|
       # ...
@@ -367,7 +366,7 @@ end
 This generates a single `UPDATE` statement to set the default value.
 
 ```ruby
-class ChangeSomeColumnNull < ActiveRecord::Migration[5.2]
+class ChangeSomeColumnNull < ActiveRecord::Migration[6.0]
   def change
     change_column_null :users, :some_column, false, "default_value"
   end
@@ -379,7 +378,7 @@ end
 Backfill the column [safely](#backfilling-data). Then use:
 
 ```ruby
-class ChangeSomeColumnNull < ActiveRecord::Migration[5.2]
+class ChangeSomeColumnNull < ActiveRecord::Migration[6.0]
   def change
     change_column_null :users, :some_column, false
   end
@@ -393,7 +392,7 @@ end
 In Postgres, there’s no equality operator for the `json` column type, which causes issues for `SELECT DISTINCT` queries.
 
 ```ruby
-class AddPropertiesToUsers < ActiveRecord::Migration[5.2]
+class AddPropertiesToUsers < ActiveRecord::Migration[6.0]
   def change
     add_column :users, :properties, :json
   end
@@ -405,7 +404,7 @@ end
 Use `jsonb` instead.
 
 ```ruby
-class AddPropertiesToUsers < ActiveRecord::Migration[5.2]
+class AddPropertiesToUsers < ActiveRecord::Migration[6.0]
   def change
     add_column :users, :properties, :jsonb
   end
@@ -421,7 +420,7 @@ end
 Adding a non-unique index with more than three columns rarely improves performance.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[5.2]
+class AddSomeIndexToUsers < ActiveRecord::Migration[6.0]
   def change
     add_index :users, [:a, :b, :c, :d]
   end
@@ -433,7 +432,7 @@ end
 Instead, start an index with columns that narrow down the results the most.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[5.2]
+class AddSomeIndexToUsers < ActiveRecord::Migration[6.0]
   def change
     add_index :users, [:b, :d]
   end
@@ -447,7 +446,7 @@ end
 To mark a step in the migration as safe, despite using a method that might otherwise be dangerous, wrap it in a `safety_assured` block.
 
 ```ruby
-class MySafeMigration < ActiveRecord::Migration[5.2]
+class MySafeMigration < ActiveRecord::Migration[6.0]
   def change
     safety_assured { remove_column :users, :some_column }
   end

data/lib/strong_migrations.rb

@@ -97,8 +97,7 @@ class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
   disable_ddl_transaction!
 
   def change
-    %{reference_command}
-    %{index_command}
+    %{command}
   end
 end",
 

data/lib/strong_migrations/checker.rb

@@ -116,12 +116,18 @@ end"
           options ||= {}
 
           index_value = options.fetch(:index, true)
-          if postgresql? && index_value
+          concurrently_set = index_value.is_a?(Hash) && index_value[:algorithm] == :concurrently
+
+          if postgresql? && index_value && !concurrently_set
             columns = options[:polymorphic] ? [:"#{reference}_type", :"#{reference}_id"] : :"#{reference}_id"
 
-            raise_error :add_reference,
-              reference_command: command_str(method, [table, reference, options.merge(index: false)]),
-              index_command: command_str("add_index", [table, columns, {algorithm: :concurrently}])
+            if index_value.is_a?(Hash)
+              options[:index] = options[:index].merge(algorithm: :concurrently)
+            else
+              options = options.merge(index: {algorithm: :concurrently})
+            end
+
+            raise_error :add_reference, command: command_str(method, [table, reference, options])
           end
         when :execute
           raise_error :execute, header: "Possibly dangerous operation"
@@ -236,7 +242,14 @@ end"
       last_arg = args[-1]
       if last_arg.is_a?(Hash)
         if last_arg.any?
-          str_args << last_arg.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+          str_args << last_arg.map do |k, v|
+            if v.is_a?(Hash)
+              # pretty index: {algorithm: :concurrently}
+              "#{k}: {#{v.map { |k2, v2| "#{k2}: #{v2.inspect}" }.join(", ")}}"
+            else
+              "#{k}: #{v.inspect}"
+            end
+          end.join(", ")
         end
       else
         str_args << last_arg.inspect

data/lib/strong_migrations/migration.rb

@@ -1,23 +1,18 @@
 module StrongMigrations
   module Migration
-    def initialize(*args)
-      super
-      @checker = StrongMigrations::Checker.new(self)
-    end
-
     def migrate(direction)
-      @checker.direction = direction
+      strong_migrations_checker.direction = direction
       super
     end
 
     def method_missing(method, *args)
-      @checker.perform(method, *args) do
+      strong_migrations_checker.perform(method, *args) do
         super
       end
     end
 
     def safety_assured
-      @checker.safety_assured do
+      strong_migrations_checker.safety_assured do
         yield
       end
     end
@@ -25,5 +20,11 @@ module StrongMigrations
     def stop!(message, header: "Custom check")
       raise StrongMigrations::UnsafeMigration, "\n=== #{header} #strong_migrations ===\n\n#{message}\n"
     end
+
+    private
+
+    def strong_migrations_checker
+      @strong_migrations_checker ||= StrongMigrations::Checker.new(self)
+    end
   end
 end

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Andrew Kane
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-12 00:00:00.000000000 Z
+date: 2019-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -122,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Catch unsafe migrations in development