strong_migrations 1.3.0 → 1.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4da88a3161110bc4e7fd6cc989ea51e0db2e32681c8026db11ac74c763f253b3
-  data.tar.gz: 583cd8b1e9665842ff6017c6d7242dcbfd9583157327b33ec023d5357c4e799f
+  metadata.gz: 7444023bd5f0829a289ebc9d222a28f041a4e3789224438f9fd6bffa01fa6668
+  data.tar.gz: feb5010616cc8ef6cf36088be7a67bb0d74272cde79d0e9a0a442272bfa92d99
 SHA512:
-  metadata.gz: 68356a9f5966f33a2a43f35a5f74ce21943798e4d85eb1c52710808dbac0efab6659d67a22d89aa4360cfc4f87e0dce6312e16f3a71dc0a739e87bb335d42f84
-  data.tar.gz: 67038470a20b75fd3dfb8642fea4775aedb08bff959255a44aa92271e2214300e9140f3d7cce21eae83e81ea314739c06999ce8d46a72f76f75f675e6c8914fb
+  metadata.gz: '0599a3fef628ec724471ef53b7ad7358831e6b638bdd0ca3b7cb79c1b416da6c044793ecca5475f5e602e8a7d1235ced3ff3fda526f31b9c4a56990c8531f9b4'
+  data.tar.gz: 6aac91ecb348c6a04c25511adf7df5d3e97823f6b9acdfbfd86bac50c4f5856f15fdcc271f00d0fc6f1e5d2cfdbaf3da5e056b1476aaf9b224e7df89b9737e01

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+## 1.4.4 (2023-03-08)
+
+- Fixed `add_foreign_key` with `name` and `column` options with `safe_by_default`
+
+## 1.4.3 (2023-02-19)
+
+- Fixed check for `change_column` to account for charset with MySQL and MariaDB
+
+## 1.4.2 (2023-01-29)
+
+- Added `alphabetize_schema` option
+
+## 1.4.1 (2023-01-05)
+
+- Added support for multiple databases to `target_version`
+
+## 1.4.0 (2022-10-31)
+
+- Added check for `add_exclusion_constraint`
+- Added support for `RACK_ENV`
+- Fixed error when `Rails` defined without `Rails.env`
+- Fixed error with `change_column_null` when table does not exist
+
+## 1.3.2 (2022-10-09)
+
+- Improved error message for `add_column` with `default: nil` with Postgres 10
+
+## 1.3.1 (2022-09-21)
+
+- Fixed check for `add_column` with `default: nil` with Postgres 10
+
 ## 1.3.0 (2022-08-30)
 
 - Added check for `add_column` with `uuid` type and volatile default value

data/README.md

@@ -74,6 +74,7 @@ Postgres-specific checks:
 - [adding an index non-concurrently](#adding-an-index-non-concurrently)
 - [adding a reference](#adding-a-reference)
 - [adding a foreign key](#adding-a-foreign-key)
+- [adding an exclusion constraint](#adding-an-exclusion-constraint)
 - [adding a json column](#adding-a-json-column)
 - [setting NOT NULL on an existing column](#setting-not-null-on-an-existing-column)
 
@@ -107,7 +108,7 @@ end
   end
   ```
 
-2. Deploy code
+2. Deploy the code
 3. Write a migration to remove the column (wrap in `safety_assured` block)
 
   ```ruby
@@ -118,7 +119,7 @@ end
   end
   ```
 
-4. Deploy and run migration
+4. Deploy and run the migration
 5. Remove the line added in step 1
 
 ### Adding a column with a default value
@@ -223,7 +224,7 @@ And some in MySQL and MariaDB:
 
 Type | Safe Changes
 --- | ---
-`string` | Increasing `:limit` from under 255 up to 255, increasing `:limit` from over 255 to the max
+`string` | Increasing `:limit` from under 63 up to 63, increasing `:limit` from over 63 to the max (the threshold can be different if using an encoding other than `utf8mb4` - for instance, it’s 85 for `utf8mb3` and 255 for `latin1`)
 
 #### Good
 
@@ -488,6 +489,24 @@ class ValidateForeignKeyOnUsers < ActiveRecord::Migration[7.0]
 end
 ```
 
+### Adding an exclusion constraint
+
+#### Bad
+
+In Postgres, adding an exclusion constraint blocks reads and writes while every row is checked.
+
+```ruby
+class AddExclusionContraint < ActiveRecord::Migration[7.1]
+  def change
+    add_exclusion_constraint :users, "number WITH =", using: :gist
+  end
+end
+```
+
+#### Good
+
+[Let us know](https://github.com/ankane/strong_migrations/issues/new) if you have a safe way to do this (exclusion constraints cannot be marked `NOT VALID`).
+
 ### Adding a json column
 
 #### Bad
@@ -805,6 +824,12 @@ The major version works well for Postgres, while the full version is recommended
 
 For safety, this option only affects development and test environments. In other environments, the actual server version is always used.
 
+If your app has multiple databases with different versions, with Rails 6.1+, you can use:
+
+```ruby
+StrongMigrations.target_version = {primary: 13, catalog: 15}
+```
+
 ## Analyze Tables
 
 Analyze tables automatically (to update planner statistics) after an index is added. Create an initializer with:
@@ -815,23 +840,18 @@ StrongMigrations.auto_analyze = true
 
 ## Faster Migrations
 
-Only dump the schema when adding a new migration. If you use Git, add to the end of your `Rakefile`:
+Only dump the schema when adding a new migration. If you use Git, add to `config/environments/development.rb`:
 
 ```rb
-task :faster_migrations do
-  ActiveRecord::Base.dump_schema_after_migration = Rails.env.development? &&
-    `git status db/migrate/ --porcelain`.present?
-end
-
-task "db:migrate": "faster_migrations"
+config.active_record.dump_schema_after_migration = `git status db/migrate/ --porcelain`.present?
 ```
 
 ## Schema Sanity
 
-Columns can flip order in `db/schema.rb` when you have multiple developers. One way to prevent this is to [alphabetize them](https://www.pgrs.net/2008/03/12/alphabetize-schema-rb-columns/). Add to the end of your `Rakefile`:
+Columns can flip order in `db/schema.rb` when you have multiple developers. One way to prevent this is to [alphabetize them](https://www.pgrs.net/2008/03/12/alphabetize-schema-rb-columns/). Add to `config/initializers/strong_migrations.rb`:
 
 ```ruby
-task "db:schema:dump": "strong_migrations:alphabetize_columns"
+StrongMigrations.alphabetize_schema = true
 ```
 
 ## Permissions

data/lib/strong_migrations/adapters/abstract_adapter.rb

@@ -50,7 +50,23 @@ module StrongMigrations
         target_version ||= StrongMigrations.target_version
         version =
           if target_version && StrongMigrations.developer_env?
-            target_version.to_s
+            if target_version.is_a?(Hash)
+              # Active Record 6.0 supports multiple databases
+              # but connection.pool.spec.name always returns "primary"
+              # in migrations with rails db:migrate
+              if ActiveRecord::VERSION::STRING.to_f < 6.1
+                # error class is not shown in db:migrate output so ensure message is descriptive
+                raise StrongMigrations::Error, "StrongMigrations.target_version does not support multiple databases for Active Record < 6.1"
+              end
+
+              db_config_name = connection.pool.db_config.name
+              target_version.stringify_keys.fetch(db_config_name) do
+                # error class is not shown in db:migrate output so ensure message is descriptive
+                raise StrongMigrations::Error, "StrongMigrations.target_version is not configured for :#{db_config_name} database"
+              end.to_s
+            else
+              target_version.to_s
+            end
           else
             yield
           end

data/lib/strong_migrations/adapters/mariadb_adapter.rb

@@ -18,6 +18,9 @@ module StrongMigrations
       end
 
       def set_statement_timeout(timeout)
+        # fix deprecation warning with Active Record 7.1
+        timeout = timeout.value if timeout.is_a?(ActiveSupport::Duration)
+
         select_all("SET max_statement_time = #{connection.quote(timeout)}")
       end
 

data/lib/strong_migrations/adapters/mysql_adapter.rb

@@ -25,6 +25,9 @@ module StrongMigrations
       end
 
       def set_lock_timeout(timeout)
+        # fix deprecation warning with Active Record 7.1
+        timeout = timeout.value if timeout.is_a?(ActiveSupport::Duration)
+
         select_all("SET lock_wait_timeout = #{connection.quote(timeout)}")
       end
 
@@ -49,14 +52,31 @@ module StrongMigrations
 
         case type.to_s
         when "string"
-          # https://dev.mysql.com/doc/refman/5.7/en/innodb-online-ddl-operations.html
-          # https://mariadb.com/kb/en/innodb-online-ddl-operations-with-the-instant-alter-algorithm/#changing-the-data-type-of-a-column
-          # increased limit, but doesn't change number of length bytes
-          # 1-255 = 1 byte, 256-65532 = 2 bytes, 65533+ = too big for varchar
           limit = options[:limit] || 255
-          safe = ["varchar"].include?(existing_type) &&
-            limit >= existing_column.limit &&
-            (limit <= 255 || existing_column.limit > 255)
+          if ["varchar"].include?(existing_type) && limit >= existing_column.limit
+            # https://dev.mysql.com/doc/refman/5.7/en/innodb-online-ddl-operations.html
+            # https://mariadb.com/kb/en/innodb-online-ddl-operations-with-the-instant-alter-algorithm/#changing-the-data-type-of-a-column
+            # increased limit, but doesn't change number of length bytes
+            # 1-255 = 1 byte, 256-65532 = 2 bytes, 65533+ = too big for varchar
+
+            # account for charset
+            # https://dev.mysql.com/doc/refman/8.0/en/charset-mysql.html
+            # https://mariadb.com/kb/en/supported-character-sets-and-collations/
+            sql = <<~SQL
+              SELECT cs.MAXLEN
+              FROM INFORMATION_SCHEMA.CHARACTER_SETS cs
+              INNER JOIN INFORMATION_SCHEMA.COLLATIONS c ON c.CHARACTER_SET_NAME = cs.CHARACTER_SET_NAME
+              INNER JOIN INFORMATION_SCHEMA.TABLES t ON t.TABLE_COLLATION = c.COLLATION_NAME
+              WHERE t.TABLE_SCHEMA = database() AND t.TABLE_NAME = #{connection.quote(table)}
+            SQL
+            row = connection.select_all(sql).first
+            if row
+              threshold = 255 / row["MAXLEN"]
+              safe = limit <= threshold || existing_column.limit > threshold
+            else
+              warn "[strong_migrations] Could not determine charset"
+            end
+          end
         end
 
         safe

data/lib/strong_migrations/checker.rb

@@ -36,6 +36,8 @@ module StrongMigrations
           check_add_check_constraint(*args)
         when :add_column
           check_add_column(*args)
+        when :add_exclusion_constraint
+          check_add_exclusion_constraint(*args)
         when :add_foreign_key
           check_add_foreign_key(*args)
         when :add_index

data/lib/strong_migrations/checks.rb

@@ -32,9 +32,11 @@ module StrongMigrations
       table, column, type = args
       default = options[:default]
 
-      # Active Record has special case for uuid columns that allows function default values
+      # Check key since DEFAULT NULL behaves differently from no default
+      #
+      # Also, Active Record has special case for uuid columns that allows function default values
       # https://github.com/rails/rails/blob/v7.0.3.1/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb#L92-L93
-      if !default.nil? && (!adapter.add_column_default_safe? || (volatile = (postgresql? && type.to_s == "uuid" && default.to_s.include?("()") && adapter.default_volatile?(default))))
+      if options.key?(:default) && (!adapter.add_column_default_safe? || (volatile = (postgresql? && type.to_s == "uuid" && default.to_s.include?("()") && adapter.default_volatile?(default))))
         if options[:null] == false
           options = options.except(:null)
           append = "
@@ -42,14 +44,21 @@ module StrongMigrations
 Then add the NOT NULL constraint in separate migrations."
         end
 
-        raise_error :add_column_default,
-          add_command: command_str("add_column", [table, column, type, options.except(:default)]),
-          change_command: command_str("change_column_default", [table, column, default]),
-          remove_command: command_str("remove_column", [table, column]),
-          code: backfill_code(table, column, default, volatile),
-          append: append,
-          rewrite_blocks: adapter.rewrite_blocks,
-          default_type: (volatile ? "volatile" : "non-null")
+        if default.nil?
+          raise_error :add_column_default_null,
+            command: command_str("add_column", [table, column, type, options.except(:default)]),
+            append: append,
+            rewrite_blocks: adapter.rewrite_blocks
+        else
+          raise_error :add_column_default,
+            add_command: command_str("add_column", [table, column, type, options.except(:default)]),
+            change_command: command_str("change_column_default", [table, column, default]),
+            remove_command: command_str("remove_column", [table, column]),
+            code: backfill_code(table, column, default, volatile),
+            append: append,
+            rewrite_blocks: adapter.rewrite_blocks,
+            default_type: (volatile ? "volatile" : "non-null")
+        end
       elsif default.is_a?(Proc) && postgresql?
         # adding a column with a VOLATILE default is not safe
         # https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-NOTES
@@ -64,6 +73,14 @@ Then add the NOT NULL constraint in separate migrations."
       end
     end
 
+    def check_add_exclusion_constraint(*args)
+      table = args[0]
+
+      unless new_table?(table)
+        raise_error :add_exclusion_constraint
+      end
+    end
+
     # unlike add_index, we don't make an exception here for new tables
     #
     # with add_index, it's fine to lock a new table even after inserting data
@@ -161,7 +178,8 @@ Then add the foreign key in separate migrations."
       table, column, type = args
 
       safe = false
-      existing_column = connection.columns(table).find { |c| c.name.to_s == column.to_s }
+      table_columns = connection.columns(table) rescue []
+      existing_column = table_columns.find { |c| c.name.to_s == column.to_s }
       if existing_column
         existing_type = existing_column.sql_type.sub(/\(\d+(,\d+)?\)/, "")
         safe = adapter.change_type_safe?(table, column, type, options, existing_column, existing_type)
@@ -222,9 +240,7 @@ Then add the foreign key in separate migrations."
 
             add_constraint_code =
               if constraint_methods
-                # only quote when needed
-                expr_column = column.to_s =~ /\A[a-z0-9_]+\z/ ? column : connection.quote_column_name(column)
-                command_str(:add_check_constraint, [table, "#{expr_column} IS NOT NULL", {name: constraint_name, validate: false}])
+                command_str(:add_check_constraint, [table, "#{quote_column_if_needed(column)} IS NOT NULL", {name: constraint_name, validate: false}])
               else
                 safety_assured_str(add_code)
               end
@@ -424,12 +440,19 @@ Then add the foreign key in separate migrations."
       model = table.to_s.classify
       if function
         # update_all(column: Arel.sql(default)) also works in newer versions of Active Record
-        "#{model}.unscoped.in_batches do |relation| \n      relation.where(#{column}: nil).update_all(\"#{column} = #{default}\")\n      sleep(0.01)\n    end"
+        update_expr = "#{quote_column_if_needed(column)} = #{default}"
+        "#{model}.unscoped.in_batches do |relation| \n      relation.where(#{column}: nil).update_all(#{update_expr.inspect})\n      sleep(0.01)\n    end"
       else
         "#{model}.unscoped.in_batches do |relation| \n      relation.update_all #{column}: #{default.inspect}\n      sleep(0.01)\n    end"
       end
     end
 
+    # only quote when needed
+    # important! only use for display purposes
+    def quote_column_if_needed(column)
+      column.to_s =~ /\A[a-z0-9_]+\z/ ? column : connection.quote_column_name(column)
+    end
+
     def new_table?(table)
       @new_tables.include?(table.to_s)
     end

data/lib/strong_migrations/error_messages.rb

@@ -25,6 +25,16 @@ class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
   end
 end",
 
+    add_column_default_null:
+"Adding a column with a null default blocks %{rewrite_blocks} while the entire table is rewritten.
+Instead, add the column without a default value.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{command}
+  end
+end",
+
     add_column_default_callable:
 "Strong Migrations does not support inspecting callable default values.
 Please make really sure you're not calling a VOLATILE function,
@@ -221,7 +231,10 @@ end",
 
     validate_check_constraint:
 "Validating a check constraint while writes are blocked is dangerous.
-Use disable_ddl_transaction! or a separate migration."
+Use disable_ddl_transaction! or a separate migration.",
+
+    add_exclusion_constraint:
+"Adding an exclusion constraint blocks reads and writes while every row is checked."
   }
   self.enabled_checks = (error_messages.keys - [:remove_index]).map { |k| [k, {}] }.to_h
 end

data/lib/strong_migrations/safe_methods.rb

@@ -48,10 +48,20 @@ module StrongMigrations
         dir.up do
           @migration.add_foreign_key(from_table, to_table, *args, **options.merge(validate: false))
           disable_transaction
-          @migration.validate_foreign_key(from_table, to_table)
+          validate_options = options.slice(:column, :name)
+          if ActiveRecord::VERSION::MAJOR >= 6
+            @migration.validate_foreign_key(from_table, to_table, **validate_options)
+          else
+            @migration.validate_foreign_key(from_table, validate_options.any? ? validate_options : to_table)
+          end
         end
         dir.down do
-          @migration.remove_foreign_key(from_table, to_table)
+          remove_options = options.slice(:column, :name)
+          if ActiveRecord::VERSION::MAJOR >= 6
+            @migration.remove_foreign_key(from_table, to_table, **remove_options)
+          else
+            @migration.remove_foreign_key(from_table, remove_options.any? ? remove_options : to_table)
+          end
         end
       end
     end
@@ -64,7 +74,7 @@ module StrongMigrations
           @migration.validate_check_constraint(table, **validate_options)
         end
         dir.down do
-          @migration.remove_check_constraint(table, expression, **add_options)
+          @migration.remove_check_constraint(table, expression, **add_options.except(:validate))
         end
       end
     end

data/lib/strong_migrations/schema_dumper.rb

@@ -0,0 +1,21 @@
+module StrongMigrations
+  module SchemaDumper
+    def initialize(connection, *args, **options)
+      return super unless StrongMigrations.alphabetize_schema
+
+      super(WrappedConnection.new(connection), *args, **options)
+    end
+  end
+
+  class WrappedConnection
+    delegate_missing_to :@connection
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def columns(*args, **options)
+      @connection.columns(*args, **options).sort_by(&:name)
+    end
+  end
+end

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "1.3.0"
+  VERSION = "1.4.4"
 end

data/lib/strong_migrations.rb

@@ -2,22 +2,22 @@
 require "active_support"
 
 # adapters
-require "strong_migrations/adapters/abstract_adapter"
-require "strong_migrations/adapters/mysql_adapter"
-require "strong_migrations/adapters/mariadb_adapter"
-require "strong_migrations/adapters/postgresql_adapter"
+require_relative "strong_migrations/adapters/abstract_adapter"
+require_relative "strong_migrations/adapters/mysql_adapter"
+require_relative "strong_migrations/adapters/mariadb_adapter"
+require_relative "strong_migrations/adapters/postgresql_adapter"
 
 # modules
-require "strong_migrations/checks"
-require "strong_migrations/safe_methods"
-require "strong_migrations/checker"
-require "strong_migrations/database_tasks"
-require "strong_migrations/migration"
-require "strong_migrations/migrator"
-require "strong_migrations/version"
+require_relative "strong_migrations/checks"
+require_relative "strong_migrations/safe_methods"
+require_relative "strong_migrations/checker"
+require_relative "strong_migrations/database_tasks"
+require_relative "strong_migrations/migration"
+require_relative "strong_migrations/migrator"
+require_relative "strong_migrations/version"
 
 # integrations
-require "strong_migrations/railtie" if defined?(Rails)
+require_relative "strong_migrations/railtie" if defined?(Rails)
 
 module StrongMigrations
   class Error < StandardError; end
@@ -28,7 +28,8 @@ module StrongMigrations
     attr_accessor :auto_analyze, :start_after, :checks, :error_messages,
       :target_postgresql_version, :target_mysql_version, :target_mariadb_version,
       :enabled_checks, :lock_timeout, :statement_timeout, :check_down, :target_version,
-      :safe_by_default, :target_sql_mode, :lock_timeout_retries, :lock_timeout_retry_delay
+      :safe_by_default, :target_sql_mode, :lock_timeout_retries, :lock_timeout_retry_delay,
+      :alphabetize_schema
     attr_writer :lock_timeout_limit
   end
   self.auto_analyze = false
@@ -38,10 +39,21 @@ module StrongMigrations
   self.checks = []
   self.safe_by_default = false
   self.check_down = false
+  self.alphabetize_schema = false
 
   # private
   def self.developer_env?
-    defined?(Rails) && (Rails.env.development? || Rails.env.test?)
+    env == "development" || env == "test"
+  end
+
+  # private
+  def self.env
+    if defined?(Rails.env)
+      Rails.env
+    else
+      # default to production for safety
+      ENV["RACK_ENV"] || "production"
+    end
   end
 
   def self.lock_timeout_limit
@@ -74,7 +86,7 @@ module StrongMigrations
 end
 
 # load error messages
-require "strong_migrations/error_messages"
+require_relative "strong_migrations/error_messages"
 
 ActiveSupport.on_load(:active_record) do
   ActiveRecord::Migration.prepend(StrongMigrations::Migration)
@@ -83,4 +95,7 @@ ActiveSupport.on_load(:active_record) do
   if defined?(ActiveRecord::Tasks::DatabaseTasks)
     ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(StrongMigrations::DatabaseTasks)
   end
+
+  require_relative "strong_migrations/schema_dumper"
+  ActiveRecord::SchemaDumper.prepend(StrongMigrations::SchemaDumper)
 end

data/lib/tasks/strong_migrations.rake

@@ -4,11 +4,6 @@ namespace :strong_migrations do
     $stderr.puts "Dumping schema"
     ActiveRecord::Base.logger.level = Logger::INFO
 
-    require "strong_migrations/alphabetize_columns"
-    ActiveRecord::Base.connection.class.prepend StrongMigrations::AlphabetizeColumns
-    if ActiveRecord::ConnectionAdapters.const_defined?('PostGISAdapter')
-      ActiveRecord::ConnectionAdapters::PostGISAdapter.prepend StrongMigrations::AlphabetizeColumns
-    end
-    ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend StrongMigrations::AlphabetizeColumns
+    StrongMigrations.alphabetize_schema = true
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.4
 platform: ruby
 authors:
 - Andrew Kane
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-30 00:00:00.000000000 Z
+date: 2023-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -45,7 +45,6 @@ files:
 - lib/strong_migrations/adapters/mariadb_adapter.rb
 - lib/strong_migrations/adapters/mysql_adapter.rb
 - lib/strong_migrations/adapters/postgresql_adapter.rb
-- lib/strong_migrations/alphabetize_columns.rb
 - lib/strong_migrations/checker.rb
 - lib/strong_migrations/checks.rb
 - lib/strong_migrations/database_tasks.rb
@@ -54,6 +53,7 @@ files:
 - lib/strong_migrations/migrator.rb
 - lib/strong_migrations/railtie.rb
 - lib/strong_migrations/safe_methods.rb
+- lib/strong_migrations/schema_dumper.rb
 - lib/strong_migrations/version.rb
 - lib/tasks/strong_migrations.rake
 homepage: https://github.com/ankane/strong_migrations
@@ -75,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: Catch unsafe migrations in development

data/lib/strong_migrations/alphabetize_columns.rb

@@ -1,11 +0,0 @@
-module StrongMigrations
-  module AlphabetizeColumns
-    def columns(*args)
-      super.sort_by(&:name)
-    end
-
-    def extensions(*args)
-      super.sort
-    end
-  end
-end