actual_db_schema 0.8.1 → 0.8.3

data/lib/actual_db_schema/git_hooks.rb

@@ -4,7 +4,7 @@ require "fileutils"
 
 module ActualDbSchema
   # Handles the installation of a git post-checkout hook that rolls back phantom migrations when switching branches
-  class GitHooks # rubocop:disable Metrics/ClassLength
+  class GitHooks
     include ActualDbSchema::OutputFormatter
 
     POST_CHECKOUT_MARKER_START = "# >>> BEGIN ACTUAL_DB_SCHEMA"

data/lib/actual_db_schema/migration.rb

@@ -73,6 +73,43 @@ module ActualDbSchema
       end
     end
 
+    def broken_versions
+      broken = []
+      MigrationContext.instance.each do |context|
+        context.migrations_status.each do |status, version, name|
+          next unless name == "********** NO FILE **********"
+
+          broken << Migration.new(
+            status: status,
+            version: version.to_s,
+            name: name,
+            branch: branch_for(version),
+            database: ActualDbSchema.db_config[:database]
+          )
+        end
+      end
+
+      broken
+    end
+
+    def delete(version, database)
+      validate_broken_migration(version, database)
+
+      MigrationContext.instance.each do
+        next if database && ActualDbSchema.db_config[:database] != database
+        next if ActiveRecord::Base.connection.select_values("SELECT version FROM schema_migrations").exclude?(version)
+
+        ActiveRecord::Base.connection.execute("DELETE FROM schema_migrations WHERE version = '#{version}'")
+        break
+      end
+    end
+
+    def delete_all
+      broken_versions.each do |version|
+        delete(version.version, version.database)
+      end
+    end
+
     private
 
     def build_migration_struct(status, migration)
@@ -92,7 +129,8 @@ module ActualDbSchema
     end
 
     def phantom?(migration)
-      migration.filename.include?("/tmp/migrated")
+      migrated_folder = ActualDbSchema.config[:migrated_folder].presence || "/tmp/migrated"
+      migration.filename.include?(migrated_folder.to_s)
     end
 
     def should_include?(status, migration)
@@ -115,5 +153,15 @@ module ActualDbSchema
       @metadata ||= {}
       @metadata[ActualDbSchema.db_config[:database]] ||= ActualDbSchema::Store.instance.read
     end
+
+    def validate_broken_migration(version, database)
+      if database
+        unless broken_versions.any? { |v| v.version == version && v.database == database }
+          raise StandardError, "Migration is not broken for database #{database}."
+        end
+      else
+        raise StandardError, "Migration is not broken." unless broken_versions.any? { |v| v.version == version }
+      end
+    end
   end
 end

data/lib/actual_db_schema/migration_parser.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require "parser/current"
+require "ast"
+
+module ActualDbSchema
+  # Parses migration files in a Rails application into a structured hash representation.
+  module MigrationParser
+    extend self
+
+    PARSER_MAPPING = {
+      add_column: ->(args) { parse_add_column(args) },
+      change_column: ->(args) { parse_change_column(args) },
+      remove_column: ->(args) { parse_remove_column(args) },
+      rename_column: ->(args) { parse_rename_column(args) },
+      add_index: ->(args) { parse_add_index(args) },
+      remove_index: ->(args) { parse_remove_index(args) },
+      rename_index: ->(args) { parse_rename_index(args) },
+      create_table: ->(args) { parse_create_table(args) },
+      drop_table: ->(args) { parse_drop_table(args) }
+    }.freeze
+
+    def parse_all_migrations(dirs)
+      changes_by_path = {}
+      handled_files = Set.new
+
+      dirs.each do |dir|
+        Dir["#{dir}/*.rb"].sort.each do |file|
+          base_name = File.basename(file)
+          next if handled_files.include?(base_name)
+
+          changes = parse_file(file).yield_self { |ast| find_migration_changes(ast) }
+          changes_by_path[file] = changes unless changes.empty?
+          handled_files.add(base_name)
+        end
+      end
+
+      changes_by_path
+    end
+
+    private
+
+    def parse_file(file_path)
+      buffer = Parser::Source::Buffer.new(file_path)
+      buffer.source = File.read(file_path, encoding: "UTF-8")
+      Parser::CurrentRuby.parse(buffer.source)
+    end
+
+    def find_migration_changes(node)
+      return [] unless node.is_a?(Parser::AST::Node)
+
+      changes = []
+      if node.type == :block
+        return process_block_node(node)
+      elsif node.type == :send
+        changes.concat(process_send_node(node))
+      end
+
+      node.children.each { |child| changes.concat(find_migration_changes(child)) if child.is_a?(Parser::AST::Node) }
+
+      changes
+    end
+
+    def process_block_node(node)
+      changes = []
+      send_node = node.children.first
+      return changes unless send_node.type == :send
+
+      method_name = send_node.children[1]
+      return changes unless method_name == :create_table
+
+      change = parse_create_table_with_block(send_node, node)
+      changes << change if change
+      changes
+    end
+
+    def process_send_node(node)
+      changes = []
+      _receiver, method_name, *args = node.children
+      if (parser = PARSER_MAPPING[method_name])
+        change = parser.call(args)
+        changes << change if change
+      end
+
+      changes
+    end
+
+    def parse_add_column(args)
+      return unless args.size >= 3
+
+      {
+        action: :add_column,
+        table: sym_value(args[0]),
+        column: sym_value(args[1]),
+        type: sym_value(args[2]),
+        options: parse_hash(args[3])
+      }
+    end
+
+    def parse_change_column(args)
+      return unless args.size >= 3
+
+      {
+        action: :change_column,
+        table: sym_value(args[0]),
+        column: sym_value(args[1]),
+        type: sym_value(args[2]),
+        options: parse_hash(args[3])
+      }
+    end
+
+    def parse_remove_column(args)
+      return unless args.size >= 2
+
+      {
+        action: :remove_column,
+        table: sym_value(args[0]),
+        column: sym_value(args[1]),
+        options: parse_hash(args[2])
+      }
+    end
+
+    def parse_rename_column(args)
+      return unless args.size >= 3
+
+      {
+        action: :rename_column,
+        table: sym_value(args[0]),
+        old_column: sym_value(args[1]),
+        new_column: sym_value(args[2])
+      }
+    end
+
+    def parse_add_index(args)
+      return unless args.size >= 2
+
+      {
+        action: :add_index,
+        table: sym_value(args[0]),
+        columns: array_or_single_value(args[1]),
+        options: parse_hash(args[2])
+      }
+    end
+
+    def parse_remove_index(args)
+      return unless args.size >= 1
+
+      {
+        action: :remove_index,
+        table: sym_value(args[0]),
+        options: parse_hash(args[1])
+      }
+    end
+
+    def parse_rename_index(args)
+      return unless args.size >= 3
+
+      {
+        action: :rename_index,
+        table: sym_value(args[0]),
+        old_name: node_value(args[1]),
+        new_name: node_value(args[2])
+      }
+    end
+
+    def parse_create_table(args)
+      return unless args.size >= 1
+
+      {
+        action: :create_table,
+        table: sym_value(args[0]),
+        options: parse_hash(args[1])
+      }
+    end
+
+    def parse_drop_table(args)
+      return unless args.size >= 1
+
+      {
+        action: :drop_table,
+        table: sym_value(args[0]),
+        options: parse_hash(args[1])
+      }
+    end
+
+    def parse_create_table_with_block(send_node, block_node)
+      args = send_node.children[2..]
+      columns = parse_create_table_columns(block_node.children[2])
+      {
+        action: :create_table,
+        table: sym_value(args[0]),
+        options: parse_hash(args[1]),
+        columns: columns
+      }
+    end
+
+    def parse_create_table_columns(body_node)
+      return [] unless body_node
+
+      nodes = body_node.type == :begin ? body_node.children : [body_node]
+      nodes.map { |node| parse_column_node(node) }.compact
+    end
+
+    def parse_column_node(node)
+      return unless node.is_a?(Parser::AST::Node) && node.type == :send
+
+      method = node.children[1]
+      return parse_timestamps if method == :timestamps
+
+      {
+        column: sym_value(node.children[2]),
+        type: method,
+        options: parse_hash(node.children[3])
+      }
+    end
+
+    def parse_timestamps
+      [
+        { column: :created_at, type: :datetime, options: { null: false } },
+        { column: :updated_at, type: :datetime, options: { null: false } }
+      ]
+    end
+
+    def sym_value(node)
+      return nil unless node && node.type == :sym
+
+      node.children.first
+    end
+
+    def array_or_single_value(node)
+      return [] unless node
+
+      if node.type == :array
+        node.children.map { |child| node_value(child) }
+      else
+        node_value(node)
+      end
+    end
+
+    def parse_hash(node)
+      return {} unless node && node.type == :hash
+
+      node.children.each_with_object({}) do |pair_node, result|
+        key_node, value_node = pair_node.children
+        key = sym_value(key_node) || node_value(key_node)
+        value = node_value(value_node)
+        result[key] = value
+      end
+    end
+
+    def node_value(node)
+      return nil unless node
+
+      case node.type
+      when :str, :sym, :int then node.children.first
+      when true then true
+      when false then false
+      when nil then nil
+      else
+        node.children.first
+      end
+    end
+  end
+end

data/lib/actual_db_schema/patches/migration_context.rb

@@ -3,7 +3,7 @@
 module ActualDbSchema
   module Patches
     # Add new command to roll back the phantom migrations
-    module MigrationContext # rubocop:disable Metrics/ModuleLength
+    module MigrationContext
       include ActualDbSchema::OutputFormatter
 
       def rollback_branches(manual_mode: false)

data/lib/actual_db_schema/railtie.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActualDbSchema
+  # Integrates the ConsoleMigrations module into the Rails console.
+  class Railtie < ::Rails::Railtie
+    console do
+      require_relative "console_migrations"
+
+      if ActualDbSchema.config[:console_migrations_enabled]
+        TOPLEVEL_BINDING.receiver.extend(ActualDbSchema::ConsoleMigrations)
+        puts "[ActualDbSchema] ConsoleMigrations enabled. You can now use migration methods directly at the console."
+      end
+    end
+  end
+end

data/lib/actual_db_schema/schema_diff.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module ActualDbSchema
+  # Generates a diff of schema changes between the current schema file and the
+  # last committed version, annotated with the migrations responsible for each change.
+  class SchemaDiff
+    include OutputFormatter
+
+    SIGN_COLORS = {
+      "+" => :green,
+      "-" => :red
+    }.freeze
+
+    CHANGE_PATTERNS = {
+      /t\.(\w+)\s+["']([^"']+)["']/ => :column,
+      /t\.index\s+.*name:\s*["']([^"']+)["']/ => :index,
+      /create_table\s+["']([^"']+)["']/ => :table
+    }.freeze
+
+    def initialize(schema_path, migrations_path)
+      @schema_path = schema_path
+      @migrations_path = migrations_path
+    end
+
+    def render
+      if old_schema_content.nil? || old_schema_content.strip.empty?
+        puts colorize("Could not retrieve old schema from git.", :red)
+        return
+      end
+
+      diff_output = generate_diff(old_schema_content, new_schema_content)
+      process_diff_output(diff_output)
+    end
+
+    private
+
+    def old_schema_content
+      @old_schema_content ||= begin
+        output = `git show HEAD:#{@schema_path} 2>&1`
+        $CHILD_STATUS.success? ? output : nil
+      end
+    end
+
+    def new_schema_content
+      @new_schema_content ||= File.read(@schema_path)
+    end
+
+    def parsed_old_schema
+      @parsed_old_schema ||= SchemaParser.parse_string(old_schema_content.to_s)
+    end
+
+    def parsed_new_schema
+      @parsed_new_schema ||= SchemaParser.parse_string(new_schema_content.to_s)
+    end
+
+    def migration_changes
+      @migration_changes ||= begin
+        migration_dirs = [@migrations_path] + migrated_folders
+        MigrationParser.parse_all_migrations(migration_dirs)
+      end
+    end
+
+    def migrated_folders
+      dirs = find_migrated_folders
+
+      if (configured_migrated_folder = ActualDbSchema.config[:migrated_folder].presence)
+        relative_migrated_folder = configured_migrated_folder.to_s.sub(%r{\A#{Regexp.escape(Rails.root.to_s)}/?}, "")
+        dirs << relative_migrated_folder unless dirs.include?(relative_migrated_folder)
+      end
+
+      dirs.map { |dir| dir.sub(%r{\A\./}, "") }.uniq
+    end
+
+    def find_migrated_folders
+      path_parts = Pathname.new(@migrations_path).each_filename.to_a
+      db_index = path_parts.index("db")
+      return [] unless db_index
+
+      base_path = db_index.zero? ? "." : File.join(*path_parts[0...db_index])
+      Dir[File.join(base_path, "tmp", "migrated*")].select do |path|
+        File.directory?(path) && File.basename(path).match?(/^migrated(_[a-zA-Z0-9_-]+)?$/)
+      end
+    end
+
+    def generate_diff(old_content, new_content)
+      Tempfile.create("old_schema") do |old_file|
+        Tempfile.create("new_schema") do |new_file|
+          old_file.write(old_content)
+          new_file.write(new_content)
+          old_file.rewind
+          new_file.rewind
+
+          return `diff -u #{old_file.path} #{new_file.path}`
+        end
+      end
+    end
+
+    def process_diff_output(diff_str)
+      lines = diff_str.lines
+      current_table = nil
+      result_lines  = []
+
+      lines.each do |line|
+        if (hunk_match = line.match(/^@@\s+-(\d+),(\d+)\s+\+(\d+),(\d+)\s+@@/))
+          current_table = find_table_in_new_schema(hunk_match[3].to_i)
+        elsif (ct = line.match(/create_table\s+["']([^"']+)["']/))
+          current_table = ct[1]
+        end
+
+        result_lines << (%w[+ -].include?(line[0]) ? handle_diff_line(line, current_table) : line)
+      end
+
+      result_lines.join
+    end
+
+    def handle_diff_line(line, current_table)
+      sign = line[0]
+      line_content = line[1..]
+      color = SIGN_COLORS[sign]
+
+      action, name = detect_action_and_name(line_content, sign, current_table)
+      annotation = action ? find_migrations(action, current_table, name) : []
+      annotated_line = annotation.any? ? annotate_line(line, annotation) : line
+
+      colorize(annotated_line, color)
+    end
+
+    def detect_action_and_name(line_content, sign, current_table)
+      action_map = {
+        column: ->(md) { [guess_action(sign, current_table, md[2]), md[2]] },
+        index: ->(md) { [sign == "+" ? :add_index : :remove_index, md[1]] },
+        table: ->(_) { [sign == "+" ? :create_table : :drop_table, nil] }
+      }
+
+      CHANGE_PATTERNS.each do |regex, kind|
+        next unless (md = line_content.match(regex))
+
+        action_proc = action_map[kind]
+        return action_proc.call(md) if action_proc
+      end
+
+      [nil, nil]
+    end
+
+    def guess_action(sign, table, col_name)
+      case sign
+      when "+"
+        old_table = parsed_old_schema[table] || {}
+        old_table[col_name].nil? ? :add_column : :change_column
+      when "-"
+        new_table = parsed_new_schema[table] || {}
+        new_table[col_name].nil? ? :remove_column : :change_column
+      end
+    end
+
+    def find_table_in_new_schema(new_line_number)
+      current_table = nil
+
+      new_schema_content.lines[0...new_line_number].each do |line|
+        if (match = line.match(/create_table\s+["']([^"']+)["']/))
+          current_table = match[1]
+        end
+      end
+      current_table
+    end
+
+    def find_migrations(action, table_name, col_or_index_name)
+      matches = []
+
+      migration_changes.each do |file_path, changes|
+        changes.each do |chg|
+          next unless chg[:table].to_s == table_name.to_s
+
+          matches << file_path if migration_matches?(chg, action, col_or_index_name)
+        end
+      end
+
+      matches
+    end
+
+    def migration_matches?(chg, action, col_or_index_name)
+      return (chg[:action] == action) if col_or_index_name.nil?
+
+      matchers = {
+        rename_column: -> { rename_column_matches?(chg, action, col_or_index_name) },
+        rename_index: -> { rename_index_matches?(chg, action, col_or_index_name) },
+        add_index: -> { index_matches?(chg, action, col_or_index_name) },
+        remove_index: -> { index_matches?(chg, action, col_or_index_name) }
+      }
+
+      matchers.fetch(chg[:action], -> { column_matches?(chg, action, col_or_index_name) }).call
+    end
+
+    def rename_column_matches?(chg, action, col)
+      (action == :remove_column && chg[:old_column].to_s == col.to_s) ||
+        (action == :add_column && chg[:new_column].to_s == col.to_s)
+    end
+
+    def rename_index_matches?(chg, action, name)
+      (action == :remove_index && chg[:old_name] == name) ||
+        (action == :add_index && chg[:new_name] == name)
+    end
+
+    def index_matches?(chg, action, col_or_index_name)
+      return false unless chg[:action] == action
+
+      extract_migration_index_name(chg, chg[:table]) == col_or_index_name.to_s
+    end
+
+    def column_matches?(chg, action, col_name)
+      chg[:column] && chg[:column].to_s == col_name.to_s && chg[:action] == action
+    end
+
+    def extract_migration_index_name(chg, table_name)
+      return chg[:options][:name].to_s if chg[:options].is_a?(Hash) && chg[:options][:name]
+
+      return "" unless (columns = chg[:columns])
+
+      cols = columns.is_a?(Array) ? columns : [columns]
+      "index_#{table_name}_on_#{cols.join("_and_")}"
+    end
+
+    def annotate_line(line, migration_file_paths)
+      "#{line.chomp}#{colorize(" // #{migration_file_paths.join(", ")} //", :gray)}\n"
+    end
+  end
+end