strong_migrations 0.3.1 → 0.7.6

data/lib/strong_migrations/database_tasks.rb

@@ -3,7 +3,7 @@ module StrongMigrations
     def migrate
       super
     rescue => e
-      if e.cause.is_a?(StrongMigrations::UnsafeMigration)
+      if e.cause.is_a?(StrongMigrations::Error)
         # strip cause and clean backtrace
         def e.cause
           nil

data/lib/strong_migrations/migration.rb

@@ -1,193 +1,32 @@
 module StrongMigrations
   module Migration
-    def safety_assured
-      previous_value = @safe
-      @safe = true
-      yield
-    ensure
-      @safe = previous_value
-    end
-
     def migrate(direction)
-      @direction = direction
+      strong_migrations_checker.direction = direction
       super
+      connection.begin_db_transaction if strong_migrations_checker.transaction_disabled
     end
 
-    def method_missing(method, *args, &block)
-      unless @safe || ENV["SAFETY_ASSURED"] || is_a?(ActiveRecord::Schema) || @direction == :down || version_safe?
-        ar5 = ActiveRecord::VERSION::MAJOR >= 5
-
-        case method
-        when :remove_column, :remove_columns, :remove_timestamps, :remove_reference, :remove_belongs_to
-          columns =
-            case method
-            when :remove_timestamps
-              ["created_at", "updated_at"]
-            when :remove_column
-              [args[1].to_s]
-            when :remove_columns
-              args[1..-1].map(&:to_s)
-            else
-              options = args[2] || {}
-              reference = args[1]
-              cols = []
-              cols << "#{reference}_type" if options[:polymorphic]
-              cols << "#{reference}_id"
-              cols
-            end
-
-          code = ar5 ? "self.ignored_columns = #{columns.inspect}" : "def self.columns\n    super.reject { |c| #{columns.inspect}.include?(c.name) }\n  end"
-
-          raise_error :remove_column,
-            model: args[0].to_s.classify,
-            code: code,
-            command: command_str(method, args),
-            column_suffix: columns.size > 1 ? "s" : ""
-        when :change_table
-          raise_error :change_table, header: "Possibly dangerous operation"
-        when :rename_table
-          raise_error :rename_table
-        when :rename_column
-          raise_error :rename_column
-        when :add_index
-          table, columns, options = args
-          options ||= {}
-
-          if columns.is_a?(Array) && columns.size > 3 && !options[:unique]
-            raise_error :add_index_columns, header: "Best practice"
-          end
-          if postgresql? && options[:algorithm] != :concurrently && !@new_tables.to_a.include?(table.to_s)
-            raise_error :add_index, command: command_str("add_index", [table, columns, options.merge(algorithm: :concurrently)])
-          end
-        when :add_column
-          table, column, type, options = args
-          options ||= {}
-          default = options[:default]
-
-          if !default.nil? && !(postgresql? && postgresql_version >= 110000)
-            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)
-          end
-
-          if type.to_s == "json" && postgresql?
-            if postgresql_version >= 90400
-              raise_error :add_column_json
-            else
-              raise_error :add_column_json_legacy,
-                model: table.to_s.classify,
-                table: connection.quote_table_name(table.to_s)
-            end
-          end
-        when :change_column
-          table, column, type = args
-
-          safe = false
-          # assume Postgres 9.1+ since previous versions are EOL
-          if postgresql? && type.to_s == "text"
-            found_column = connection.columns(table).find { |c| c.name.to_s == column.to_s }
-            safe = found_column && found_column.type == :string
-          end
-          raise_error :change_column unless safe
-        when :create_table
-          table, options = args
-          options ||= {}
-
-          raise_error :create_table if options[:force]
-
-          # keep track of new tables of add_index check
-          (@new_tables ||= []) << table.to_s
-        when :add_reference, :add_belongs_to
-          table, reference, options = args
-          options ||= {}
-
-          index_value = options.fetch(:index, ar5)
-          if postgresql? && index_value
-            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}])
-          end
-        when :execute
-          raise_error :execute, header: "Possibly dangerous operation"
-        when :change_column_null
-          table, column, null, default = args
-          if !null && !default.nil?
-            raise_error :change_column_null,
-              code: backfill_code(table, column, default)
-          end
-        end
-
-        StrongMigrations.checks.each do |check|
-          instance_exec(method, args, &check)
-        end
-      end
-
-      result = super
-
-      if StrongMigrations.auto_analyze && @direction == :up && postgresql? && method == :add_index
-        connection.execute "ANALYZE VERBOSE #{connection.quote_table_name(args[0].to_s)}"
+    def method_missing(method, *args)
+      strong_migrations_checker.perform(method, *args) do
+        super
       end
-
-      result
     end
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
-    private
-
-    def postgresql?
-      %w(PostgreSQL PostGIS).include?(connection.adapter_name)
-    end
-
-    def postgresql_version
-      @postgresql_version ||= connection.execute("SHOW server_version_num").first["server_version_num"].to_i
-    end
-
-    def version_safe?
-      version && version <= StrongMigrations.start_after
-    end
-
-    def raise_error(message_key, header: nil, **vars)
-      message = StrongMigrations.error_messages[message_key] || "Missing message"
-
-      ar5 = ActiveRecord::VERSION::MAJOR >= 5
-      vars[:migration_name] = self.class.name
-      vars[:migration_suffix] = ar5 ? "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]" : ""
-      vars[:base_model] = ar5 ? "ApplicationRecord" : "ActiveRecord::Base"
-
-      # escape % not followed by {
-      stop!(message.gsub(/%(?!{)/, "%%") % vars, header: header || "Dangerous operation detected")
-    end
-
-    def command_str(command, args)
-      str_args = args[0..-2].map { |a| a.inspect }
-
-      # prettier last arg
-      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(", ")
-        end
-      else
-        str_args << last_arg.inspect
-      end
-
-      "#{command} #{str_args.join(", ")}"
-    end
-
-    def backfill_code(table, column, default)
-      model = table.to_s.classify
-      if ActiveRecord::VERSION::MAJOR >= 5
-        "#{model}.in_batches.update_all #{column}: #{default.inspect}"
-      else
-        "#{model}.find_in_batches do |records|\n      #{model}.where(id: records.map(&:id)).update_all #{column}: #{default.inspect}\n    end"
+    def safety_assured
+      strong_migrations_checker.safety_assured do
+        yield
       end
     end
 
     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/railtie.rb

@@ -5,10 +5,6 @@ module StrongMigrations
   class Railtie < Rails::Railtie
     rake_tasks do
       load "tasks/strong_migrations.rake"
-
-      ["db:drop", "db:reset", "db:schema:load", "db:structure:load"].each do |t|
-        Rake::Task[t].enhance ["strong_migrations:safety_assured"]
-      end
     end
   end
 end

data/lib/strong_migrations/safe_methods.rb

@@ -0,0 +1,125 @@
+module StrongMigrations
+  module SafeMethods
+    def safe_by_default_method?(method)
+      StrongMigrations.safe_by_default && [:add_index, :add_belongs_to, :add_reference, :remove_index, :add_foreign_key, :add_check_constraint, :change_column_null].include?(method)
+    end
+
+    # TODO check if invalid index with expected name exists and remove if needed
+    def safe_add_index(table, columns, options)
+      disable_transaction
+      @migration.add_index(table, columns, **options.merge(algorithm: :concurrently))
+    end
+
+    def safe_remove_index(table, options)
+      disable_transaction
+      @migration.remove_index(table, **options.merge(algorithm: :concurrently))
+    end
+
+    def safe_add_reference(table, reference, options)
+      @migration.reversible do |dir|
+        dir.up do
+          disable_transaction
+          foreign_key = options.delete(:foreign_key)
+          @migration.add_reference(table, reference, **options)
+          if foreign_key
+            # same as Active Record
+            name =
+              if foreign_key.is_a?(Hash) && foreign_key[:to_table]
+                foreign_key[:to_table]
+              else
+                (ActiveRecord::Base.pluralize_table_names ? reference.to_s.pluralize : reference).to_sym
+              end
+
+            @migration.add_foreign_key(table, name)
+          end
+        end
+        dir.down do
+          @migration.remove_reference(table, reference)
+        end
+      end
+    end
+
+    def safe_add_foreign_key(from_table, to_table, options)
+      @migration.reversible do |dir|
+        dir.up do
+          @migration.add_foreign_key(from_table, to_table, **options.merge(validate: false))
+          disable_transaction
+          @migration.validate_foreign_key(from_table, to_table)
+        end
+        dir.down do
+          @migration.remove_foreign_key(from_table, to_table)
+        end
+      end
+    end
+
+    def safe_add_foreign_key_code(from_table, to_table, add_code, validate_code)
+      @migration.reversible do |dir|
+        dir.up do
+          @migration.safety_assured do
+            @migration.execute(add_code)
+            disable_transaction
+            @migration.execute(validate_code)
+          end
+        end
+        dir.down do
+          @migration.remove_foreign_key(from_table, to_table)
+        end
+      end
+    end
+
+    def safe_add_check_constraint(table, expression, add_options, validate_options)
+      @migration.reversible do |dir|
+        dir.up do
+          @migration.add_check_constraint(table, expression, **add_options)
+          disable_transaction
+          @migration.validate_check_constraint(table, **validate_options)
+        end
+        dir.down do
+          @migration.remove_check_constraint(table, expression, **add_options)
+        end
+      end
+    end
+
+    def safe_change_column_null(add_code, validate_code, change_args, remove_code)
+      @migration.reversible do |dir|
+        dir.up do
+          @migration.safety_assured do
+            @migration.execute(add_code)
+            disable_transaction
+            @migration.execute(validate_code)
+          end
+          if change_args
+            @migration.change_column_null(*change_args)
+            @migration.safety_assured do
+              @migration.execute(remove_code)
+            end
+          end
+        end
+        dir.down do
+          if change_args
+            down_args = change_args.dup
+            down_args[2] = true
+            @migration.change_column_null(*down_args)
+          else
+            @migration.safety_assured do
+              @migration.execute(remove_code)
+            end
+          end
+        end
+      end
+    end
+
+    # hard to commit at right time when reverting
+    # so just commit at start
+    def disable_transaction
+      if in_transaction? && !transaction_disabled
+        @migration.connection.commit_db_transaction
+        self.transaction_disabled = true
+      end
+    end
+
+    def in_transaction?
+      @migration.connection.open_transactions > 0
+    end
+  end
+end

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "0.3.1"
+  VERSION = "0.7.6"
 end

data/lib/tasks/strong_migrations.rake

@@ -1,10 +1,4 @@
-# http://nithinbekal.com/posts/safe-rake-tasks
-
 namespace :strong_migrations do
-  task safety_assured: :environment do
-    raise "Set SAFETY_ASSURED=1 to run this task in production" if Rails.env.production? && !ENV["SAFETY_ASSURED"]
-  end
-
   # https://www.pgrs.net/2008/03/13/alphabetize-schema-rb-columns/
   task :alphabetize_columns do
     $stderr.puts "Dumping schema"

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.7.6
 platform: ruby
 authors:
 - Andrew Kane
 - Bob Remeika
 - David Waller
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-10-19 00:00:00.000000000 Z
+date: 2021-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,14 +18,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -72,17 +72,31 @@ dependencies:
   name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
-description: 
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
 email:
 - andrew@chartkick.com
 - bob.remeika@gmail.com
@@ -94,19 +108,22 @@ files:
 - CONTRIBUTING.md
 - LICENSE.txt
 - README.md
+- lib/generators/strong_migrations/install_generator.rb
+- lib/generators/strong_migrations/templates/initializer.rb.tt
 - lib/strong_migrations.rb
 - lib/strong_migrations/alphabetize_columns.rb
+- lib/strong_migrations/checker.rb
 - lib/strong_migrations/database_tasks.rb
 - lib/strong_migrations/migration.rb
 - lib/strong_migrations/railtie.rb
-- lib/strong_migrations/unsafe_migration.rb
+- lib/strong_migrations/safe_methods.rb
 - lib/strong_migrations/version.rb
 - lib/tasks/strong_migrations.rake
 homepage: https://github.com/ankane/strong_migrations
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -114,16 +131,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.2'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
-summary: Catch unsafe migrations at dev time
+summary: Catch unsafe migrations in development
 test_files: []