nandi 0.9.0

data/lib/nandi/renderers.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "nandi/renderers/active_record"
+
+module Nandi
+  module Renderers; end
+end

data/lib/nandi/renderers/active_record.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "nandi/renderers/active_record/generate"
+
+module Nandi
+  module Renderers
+    module ActiveRecord
+      def self.generate(migration)
+        Generate.call(migration)
+      end
+    end
+  end
+end

data/lib/nandi/renderers/active_record/generate.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "cell"
+require "tilt"
+require "nandi/renderers/active_record/instructions"
+
+module Nandi
+  module Renderers
+    module ActiveRecord
+      class Generate < ::Cell::ViewModel
+        def self.call(*args)
+          super.call
+        end
+
+        def partials_base
+          "nandi/renderers/active_record/instructions"
+        end
+
+        def template_options_for(_options)
+          {
+            suffix: "rb.erb",
+            template_class: Tilt,
+          }
+        end
+
+        self.view_paths = [
+          File.expand_path("../../../templates", __dir__),
+        ]
+
+        def should_disable_ddl_transaction?
+          [*up_instructions, *down_instructions].
+            select { |i| i.procedure =~ /index/ }.any?
+        end
+
+        def activerecord_version
+          ::ActiveRecord::Migration.current_version
+        end
+
+        def render_partial(instruction)
+          if instruction.respond_to?(:template)
+            cell(instruction.template, instruction)
+          else
+            cell("#{partials_base}/#{instruction.procedure}", instruction)
+          end
+        end
+
+        property :up_instructions
+        property :down_instructions
+        property :name
+        property :mixins
+        property :disable_lock_timeout?
+        property :disable_statement_timeout?
+        property :lock_timeout
+        property :statement_timeout
+      end
+    end
+  end
+end

data/lib/nandi/renderers/active_record/instructions.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "cells"
+require "tilt"
+require "nandi/formatting"
+require "ostruct"
+
+module Nandi
+  module Renderers
+    module ActiveRecord
+      module Instructions
+        class Base < ::Cell::ViewModel
+          include Nandi::Formatting
+
+          def template_options_for(_options)
+            {
+              suffix: "rb.erb",
+              template_class: Tilt,
+            }
+          end
+
+          self.view_paths = [
+            File.join(__dir__, "../../../templates"),
+          ]
+        end
+
+        class RemoveIndexCell < Base
+          formatted_property :table
+          formatted_property :extra_args
+        end
+
+        class AddIndexCell < Base
+          formatted_property :table
+          formatted_property :fields
+          formatted_property :extra_args
+        end
+
+        class CreateTableCell < Base
+          formatted_property :table
+          formatted_property :timestamps_args
+
+          def timestamps?
+            !model.timestamps_args.nil?
+          end
+
+          def timestamps_args?
+            !model.timestamps_args&.empty?
+          end
+
+          def extra_args?
+            model.extra_args&.any?
+          end
+
+          def timestamps_args
+            format_value(model.timestamps_args, as_argument: true)
+          end
+
+          def extra_args
+            format_value(model.extra_args, as_argument: true)
+          end
+
+          def columns
+            model.columns.map do |c|
+              OpenStruct.new(
+                name: format_value(c.name),
+                type: format_value(c.type),
+              ).tap do |col|
+                col.args = format_value(c.args, as_argument: true) unless c.args.empty?
+              end
+            end
+          end
+        end
+
+        class DropTableCell < Base
+          formatted_property :table
+        end
+
+        class AddColumnCell < Base
+          formatted_property :table
+          formatted_property :name
+          formatted_property :type
+          formatted_property :extra_args
+        end
+
+        class RemoveColumnCell < Base
+          formatted_property :table
+          formatted_property :name
+          formatted_property :extra_args
+        end
+
+        class ChangeColumnDefaultCell < Base
+          formatted_property :table
+          formatted_property :column
+          formatted_property :value
+        end
+
+        class RemoveNotNullConstraintCell < Base
+          formatted_property :table
+          formatted_property :column
+        end
+
+        class AddForeignKeyCell < Base
+          formatted_property :table
+          formatted_property :target
+          formatted_property :extra_args
+        end
+
+        class AddCheckConstraintCell < Base
+          # Because all this stuff goes into a SQL string, we don't need to format
+          # the values.
+          property :table
+          property :name
+          property :check
+        end
+
+        class ValidateConstraintCell < Base
+          # Because all this stuff goes into a SQL string, we don't need to format
+          # the values.
+          property :table
+          property :name
+        end
+
+        class DropConstraintCell < Base
+          # Because all this stuff goes into a SQL string, we don't need to format
+          # the values.
+          property :table
+          property :name
+        end
+
+        class IrreversibleMigrationCell < Base; end
+      end
+    end
+  end
+end

data/lib/nandi/safe_migration_enforcer.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "digest"
+require "rails"
+require "rails/generators"
+
+require "nandi/file_diff"
+require "nandi/file_matcher"
+require "nandi/lockfile"
+
+module Nandi
+  class SafeMigrationEnforcer
+    class MigrationLintingFailed < StandardError; end
+
+    DEFAULT_SAFE_MIGRATION_DIR = "db/safe_migrations"
+    DEFAULT_AR_MIGRATION_DIR = "db/migrate"
+    DEFAULT_FILE_SPEC = "all"
+
+    def initialize(require_path: nil,
+                   safe_migration_dir: DEFAULT_SAFE_MIGRATION_DIR,
+                   ar_migration_dir: DEFAULT_AR_MIGRATION_DIR,
+                   files: DEFAULT_FILE_SPEC)
+      @safe_migration_dir = safe_migration_dir
+      @ar_migration_dir = ar_migration_dir
+      @files = files
+
+      require require_path unless require_path.nil?
+
+      Nandi.configure do |c|
+        c.migration_directory = @safe_migration_dir
+        c.output_directory = @ar_migration_dir
+      end
+    end
+
+    def run
+      safe_migrations = matching_migrations(@safe_migration_dir)
+      ar_migrations = matching_migrations(@ar_migration_dir)
+
+      return true if safe_migrations.none? && ar_migrations.none?
+
+      enforce_no_ungenerated_migrations!(safe_migrations, ar_migrations)
+      enforce_no_hand_written_migrations!(safe_migrations, ar_migrations)
+      enforce_no_hand_edited_migrations!(ar_migrations)
+      enforce_no_out_of_date_migrations!(safe_migrations)
+
+      true
+    end
+
+    private
+
+    def matching_migrations(dir)
+      names = Dir.glob(File.join(dir, "*.rb")).map { |path| File.basename(path) }
+      FileMatcher.call(files: names, spec: @files)
+    end
+
+    def enforce_no_ungenerated_migrations!(safe_migrations, ar_migrations)
+      ungenerated_migrations = safe_migrations - ar_migrations
+      if ungenerated_migrations.any?
+        error = <<~ERROR
+          The following migrations are pending generation:
+
+            - #{ungenerated_migrations.sort.join("\n  - ")}
+
+          Please run `rails generate nandi:compile` to generate your migrations.
+        ERROR
+
+        raise MigrationLintingFailed, error
+      end
+    end
+
+    def enforce_no_hand_written_migrations!(safe_migrations, ar_migrations)
+      handwritten_migrations = ar_migrations - safe_migrations
+      handwritten_migration_paths = names_to_paths(handwritten_migrations)
+
+      if handwritten_migration_paths.any?
+        error = <<~ERROR
+          The following migrations have been written by hand, not generated:
+
+            - #{handwritten_migration_paths.sort.join("\n  - ")}
+
+          Please use Nandi to generate your migrations. In exeptional cases, hand-written
+          ActiveRecord migrations can be added to the .nandiignore file. Doing so will
+          require additional review that will slow your PR down.
+        ERROR
+
+        raise MigrationLintingFailed, error
+      end
+    end
+
+    def enforce_no_out_of_date_migrations!(safe_migrations)
+      out_of_date_migrations = safe_migrations.
+        map { |m| [m, Nandi::Lockfile.get(m)] }.
+        select do |filename, digests|
+          Nandi::FileDiff.new(
+            file_path: File.join(@safe_migration_dir, filename),
+            known_digest: digests[:source_digest],
+          ).changed?
+        end
+
+      if out_of_date_migrations.any?
+        error = <<~ERROR
+          The following migrations have changed but not been recompiled:
+
+            - #{out_of_date_migrations.sort.join("\n  - ")}
+
+          Please recompile your migrations to make sure that the changes you expect are
+          applied.
+        ERROR
+
+        raise MigrationLintingFailed, error
+      end
+    end
+
+    def enforce_no_hand_edited_migrations!(ar_migrations)
+      hand_altered_migrations = ar_migrations.
+        map { |m| [m, Nandi::Lockfile.get(m)] }.
+        select do |filename, digests|
+          Nandi::FileDiff.new(
+            file_path: File.join(@ar_migration_dir, filename),
+            known_digest: digests[:compiled_digest],
+          ).changed?
+        end
+
+      if hand_altered_migrations.any?
+        error = <<~ERROR
+          The following migrations have had their generated content altered:
+
+            - #{hand_altered_migrations.sort.join("\n  - ")}
+
+          Please don't hand-edit generated migrations. If you want to write a regular
+          ActiveRecord::Migration, please do so and add it to .nandiignore. Note that
+          this will require additional review that will slow your PR down.
+        ERROR
+
+        raise MigrationLintingFailed, error
+      end
+    end
+
+    def names_to_paths(names)
+      names.map { |name| File.join(@ar_migration_dir, name) }
+    end
+  end
+end

data/lib/nandi/timeout_policies.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "nandi/validation/failure_helpers"
+require "nandi/migration"
+require "nandi/timeout_policies/access_exclusive"
+require "nandi/timeout_policies/concurrent"
+
+module Nandi
+  module TimeoutPolicies
+    CONCURRENT_OPERATIONS = %i[add_index remove_index].freeze
+    class Noop
+      class << self
+        include Nandi::Validation::FailureHelpers
+
+        def validate(_)
+          success
+        end
+      end
+    end
+
+    def self.policy_for(instruction)
+      case instruction.lock
+      when Nandi::Migration::LockWeights::ACCESS_EXCLUSIVE
+        AccessExclusive
+      else
+        share_policy_for(instruction)
+      end
+    end
+
+    def self.share_policy_for(instruction)
+      if CONCURRENT_OPERATIONS.include?(instruction.procedure)
+        Concurrent
+      else
+        Noop
+      end
+    end
+  end
+end

data/lib/nandi/timeout_policies/access_exclusive.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "nandi"
+require "nandi/validation/failure_helpers"
+
+module Nandi
+  module TimeoutPolicies
+    class AccessExclusive
+      include Nandi::Validation::FailureHelpers
+
+      def self.validate(migration)
+        new(migration).validate
+      end
+
+      def initialize(migration)
+        @migration = migration
+      end
+
+      def validate
+        collect_errors(validate_statement_timeout, validate_lock_timeout)
+      end
+
+      private
+
+      attr_reader :migration
+
+      def validate_statement_timeout
+        assert(
+          !migration.disable_statement_timeout? &&
+          migration.statement_timeout <= statement_timeout_maximum,
+          "statement timeout must be at most #{statement_timeout_maximum}ms" \
+          " as it takes an ACCESS EXCLUSIVE lock",
+        )
+      end
+
+      def validate_lock_timeout
+        assert(
+          !migration.disable_lock_timeout? &&
+          migration.lock_timeout <= lock_timeout_maximum,
+          "lock timeout must be at most #{lock_timeout_maximum}ms" \
+          " as it takes an ACCESS EXCLUSIVE lock",
+        )
+      end
+
+      def statement_timeout_maximum
+        Nandi.config.access_exclusive_statement_timeout_limit
+      end
+
+      def lock_timeout_maximum
+        Nandi.config.access_exclusive_lock_timeout_limit
+      end
+    end
+  end
+end