actual_db_schema 0.8.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9197558d7b71582d339535933b2186c9ce3db7d0c4dd492759db5a226931ddf8
-  data.tar.gz: ccd05c4164478a54130c6bee32a234abbb2f193292438b8d35b6d7edd313802c
+  metadata.gz: b4b87fc03cd39a068d303e4e3844a66eb4bd8ced5c7e934c804c0049a3ff141f
+  data.tar.gz: ab30dd516f5c492b2de6e8a41f6d22adcbdc49623a2329ff1948a8114c754823
 SHA512:
-  metadata.gz: b12528875d4b7d5b12739b1a37877d979bccc6d66f7a0006454ae260b1215eb69bb5baa2aae332e68bc4f1fa29859e4b00a427591cf78acf2aebc57264889a46
-  data.tar.gz: ae2baeaae67451740cc6773abbc79e4d0896baf96b99e7c2baebe027c1b7b05bbbbb75da5717be47c43d240835810a1681408e79c3d44449f7f44c3d4e8830a6
+  metadata.gz: dfa64d7885732bc7e736dcff0c3a66ab5c30d05e80695a729ef8c48c9d478cee8ada3d3dd4566ff0824f884cfd0d244c367915d55971a79ee4a5b60fc53a9e67
+  data.tar.gz: 72a54dd856b12990db02432c63d2aa992e77596ea3af0a4b6e3f83bf31be0a6069edd60222940773adf53f5a3fb286031fa512c7146bacf60fd3fc5424d56036

data/.rubocop.yml

@@ -22,9 +22,12 @@ Metrics/BlockLength:
     - actual_db_schema.gemspec
 
 Metrics/MethodLength:
+  Max: 15
   Exclude:
     -  test/**/*
 
 Metrics/ClassLength:
-  Exclude:
-    -  test/**/*
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [0.8.2] - 2025-02-06
+
+- Show migration name in the schema.rb diff that caused the change
+- Easy way to run DDL migration methods in Rails console
+
 ## [0.8.1] - 2025-01-15
 
 - Support for multiple database schemas, ensuring compatibility with multi-tenant applications using the apartment gem or similar solutions

data/Gemfile.lock

@@ -1,10 +1,12 @@
 PATH
   remote: .
   specs:
-    actual_db_schema (0.8.1)
+    actual_db_schema (0.8.2)
       activerecord
       activesupport
+      ast
       csv
+      parser
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -168,6 +168,66 @@ config.multi_tenant_schemas = -> { # list of all active schemas }
 config.multi_tenant_schemas = -> { ["public", "tenant1", "tenant2"] }
 ```
 
+## Schema Diff with Migration Annotations
+
+If `schema.rb` generates a diff, it can be helpful to find out which migrations caused the changes. This helps you decide whether to resolve the diff on your own or discuss it with your teammates to determine the next steps. The `diff_schema_with_migrations` Rake task generates a diff of the `schema.rb` file, annotated with the migrations responsible for each change. This makes it easier to trace which migration introduced a specific schema modification, enabling faster and more informed decision-making regarding how to handle the diff.
+
+By default, the task uses `db/schema.rb` and `db/migrate` as the schema and migrations paths. You can also provide custom paths as arguments.
+
+### Usage
+
+Run the task with default paths:
+```sh
+rake actual_db_schema:diff_schema_with_migrations
+```
+
+Run the task with custom paths:
+```sh
+rake actual_db_schema:diff_schema_with_migrations[path/to/custom_schema.rb, path/to/custom_migrations]
+```
+
+## Console Migrations
+
+Sometimes, it's necessary to modify the database without creating migration files. This can be useful for fixing a corrupted schema, conducting experiments (such as adding and removing indexes), or quickly adjusting the schema in development. This gem allows you to run the same commands used in migrations directly in the Rails console.
+
+By default, Console Migrations is disabled. You can enable it in two ways:
+
+### 1. Using Environment Variable
+
+Set the environment variable `ACTUAL_DB_SCHEMA_CONSOLE_MIGRATIONS_ENABLED` to `true`:
+
+```sh
+export ACTUAL_DB_SCHEMA_CONSOLE_MIGRATIONS_ENABLED=true
+```
+
+### 2. Using Initializer
+
+Add the following line to your initializer file (`config/initializers/actual_db_schema.rb`):
+
+```ruby
+config.console_migrations_enabled = true
+```
+
+### Usage
+
+Once enabled, you can run migration commands directly in the Rails console:
+
+```ruby
+# Create a new table
+create_table :posts do |t|
+  t.string :title
+end
+
+# Add a column
+add_column :users, :age, :integer
+
+# Remove an index
+remove_index :users, :email
+
+# Rename a column
+rename_column :users, :username, :handle
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/actual_db_schema.gemspec

@@ -37,7 +37,9 @@ Gem::Specification.new do |spec|
   # Uncomment to register a new dependency of your gem
   spec.add_runtime_dependency "activerecord"
   spec.add_runtime_dependency "activesupport"
+  spec.add_runtime_dependency "ast"
   spec.add_runtime_dependency "csv"
+  spec.add_runtime_dependency "parser"
 
   spec.add_development_dependency "appraisal"
   spec.add_development_dependency "debug"

data/lib/actual_db_schema/configuration.rb

@@ -3,7 +3,8 @@
 module ActualDbSchema
   # Manages the configuration settings for the gem.
   class Configuration
-    attr_accessor :enabled, :auto_rollback_disabled, :ui_enabled, :git_hooks_enabled, :multi_tenant_schemas
+    attr_accessor :enabled, :auto_rollback_disabled, :ui_enabled, :git_hooks_enabled, :multi_tenant_schemas,
+                  :console_migrations_enabled
 
     def initialize
       @enabled = Rails.env.development?
@@ -11,6 +12,7 @@ module ActualDbSchema
       @ui_enabled = Rails.env.development? || ENV["ACTUAL_DB_SCHEMA_UI_ENABLED"].present?
       @git_hooks_enabled = ENV["ACTUAL_DB_SCHEMA_GIT_HOOKS_ENABLED"].present?
       @multi_tenant_schemas = nil
+      @console_migrations_enabled = ENV["ACTUAL_DB_SCHEMA_CONSOLE_MIGRATIONS_ENABLED"].present?
     end
 
     def [](key)

data/lib/actual_db_schema/console_migrations.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActualDbSchema
+  # Provides methods for executing schema modification commands directly in the Rails console.
+  module ConsoleMigrations
+    extend self
+
+    SCHEMA_METHODS = %i[
+      create_table
+      create_join_table
+      drop_table
+      change_table
+      add_column
+      remove_column
+      change_column
+      change_column_null
+      change_column_default
+      rename_column
+      add_index
+      remove_index
+      rename_index
+      add_timestamps
+      remove_timestamps
+      reversible
+      add_reference
+      remove_reference
+      add_foreign_key
+      remove_foreign_key
+    ].freeze
+
+    SCHEMA_METHODS.each do |method_name|
+      define_method(method_name) do |*args, **kwargs, &block|
+        if kwargs.any?
+          migration_instance.public_send(method_name, *args, **kwargs, &block)
+        else
+          migration_instance.public_send(method_name, *args, &block)
+        end
+      end
+    end
+
+    private
+
+    def migration_instance
+      @migration_instance ||= Class.new(ActiveRecord::Migration[ActiveRecord::Migration.current_version]) {}.new
+    end
+  end
+end

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_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,221 @@
+# 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
+      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])
+      dirs = Dir[File.join(base_path, "tmp", "migrated*")].select do |path|
+        File.directory?(path) && File.basename(path).match?(/^migrated(_[a-zA-Z0-9_-]+)?$/)
+      end
+
+      dirs.map { |dir| dir.sub(%r{\A\./}, "") }
+    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

data/lib/actual_db_schema/schema_parser.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "parser/current"
+require "parser/ast/processor"
+
+module ActualDbSchema
+  # Parses the content of a `schema.rb` file into a structured hash representation.
+  module SchemaParser
+    module_function
+
+    def parse_string(schema_content)
+      buffer = Parser::Source::Buffer.new("(schema)")
+      buffer.source = schema_content
+      parser = Parser::CurrentRuby.new
+      ast = parser.parse(buffer)
+
+      collector = SchemaCollector.new
+      collector.process(ast)
+      collector.schema
+    end
+
+    # Internal class used to process the AST and collect schema information.
+    class SchemaCollector < Parser::AST::Processor
+      attr_reader :schema
+
+      def initialize
+        super()
+        @schema = {}
+      end
+
+      def on_block(node)
+        send_node, _args_node, body = *node
+
+        if create_table_call?(send_node)
+          table_name = extract_table_name(send_node)
+          columns    = extract_columns(body)
+          @schema[table_name] = columns if table_name
+        end
+
+        super
+      end
+
+      def on_send(node)
+        _receiver, method_name, *args = *node
+        if method_name == :create_table && args.any?
+          table_name = extract_table_name(node)
+          @schema[table_name] ||= {}
+        end
+
+        super
+      end
+
+      private
+
+      def create_table_call?(node)
+        return false unless node.is_a?(Parser::AST::Node)
+
+        _receiver, method_name, *_args = node.children
+        method_name == :create_table
+      end
+
+      def extract_table_name(send_node)
+        _receiver, _method_name, table_arg, *_rest = send_node.children
+        return unless table_arg
+
+        case table_arg.type
+        when :str then table_arg.children.first
+        when :sym then table_arg.children.first.to_s
+        end
+      end
+
+      def extract_columns(body_node)
+        return {} unless body_node
+
+        children = body_node.type == :begin ? body_node.children : [body_node]
+
+        columns = {}
+        children.each do |expr|
+          col = process_column_node(expr)
+          columns[col[:name]] = { type: col[:type], options: col[:options] } if col && col[:name]
+        end
+        columns
+      end
+
+      def process_column_node(node)
+        return unless node.is_a?(Parser::AST::Node)
+        return unless node.type == :send
+
+        receiver, method_name, column_node, *args = node.children
+
+        return unless receiver && receiver.type == :lvar
+
+        return { name: "timestamps", type: :timestamps, options: {} } if method_name == :timestamps
+
+        col_name = extract_column_name(column_node)
+        options  = extract_column_options(args)
+
+        { name: col_name, type: method_name, options: options }
+      end
+
+      def extract_column_name(node)
+        return nil unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :str then node.children.first
+        when :sym then node.children.first.to_s
+        end
+      end
+
+      def extract_column_options(args)
+        opts = {}
+        args.each do |arg|
+          next unless arg && arg.type == :hash
+
+          opts.merge!(parse_hash(arg))
+        end
+        opts
+      end
+
+      def parse_hash(node)
+        hash = {}
+        return hash unless node && node.type == :hash
+
+        node.children.each do |pair|
+          key_node, value_node = pair.children
+          key = extract_key(key_node)
+          value = extract_literal(value_node)
+          hash[key] = value
+        end
+        hash
+      end
+
+      def extract_key(node)
+        return unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :sym then node.children.first
+        when :str then node.children.first.to_sym
+        end
+      end
+
+      def extract_literal(node)
+        return unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :int, :str, :sym then node.children.first
+        when true then true
+        when false then false
+        end
+      end
+    end
+  end
+end

data/lib/actual_db_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActualDbSchema
-  VERSION = "0.8.1"
+  VERSION = "0.8.2"
 end

data/lib/actual_db_schema.rb

@@ -10,12 +10,16 @@ require_relative "actual_db_schema/version"
 require_relative "actual_db_schema/migration"
 require_relative "actual_db_schema/failed_migration"
 require_relative "actual_db_schema/migration_context"
+require_relative "actual_db_schema/migration_parser"
 require_relative "actual_db_schema/output_formatter"
 require_relative "actual_db_schema/patches/migration_proxy"
 require_relative "actual_db_schema/patches/migrator"
 require_relative "actual_db_schema/patches/migration_context"
 require_relative "actual_db_schema/git_hooks"
 require_relative "actual_db_schema/multi_tenant"
+require_relative "actual_db_schema/railtie"
+require_relative "actual_db_schema/schema_diff"
+require_relative "actual_db_schema/schema_parser"
 
 require_relative "actual_db_schema/commands/base"
 require_relative "actual_db_schema/commands/rollback"

data/lib/generators/actual_db_schema/templates/actual_db_schema.rb

@@ -20,4 +20,8 @@ ActualDbSchema.configure do |config|
 
   # If your application leverages multiple schemas for multi-tenancy, define the active schemas.
   # config.multi_tenant_schemas = -> { ["public", "tenant1", "tenant2"] }
+
+  # Enable console migrations
+  # config.console_migrations_enabled = true
+  config.console_migrations_enabled = ENV["ACTUAL_DB_SCHEMA_CONSOLE_MIGRATIONS_ENABLED"].present?
 end

data/lib/tasks/actual_db_schema.rake

@@ -53,4 +53,13 @@ namespace :actual_db_schema do # rubocop:disable Metrics/BlockLength
       ActualDbSchema::GitHooks.new(strategy: strategy).install_post_checkout_hook
     end
   end
+
+  desc "Show the schema.rb diff annotated with the migrations that made the changes"
+  task :diff_schema_with_migrations, [:schema_path, :migrations_path] do |_, args|
+    schema_path = args[:schema_path] || "db/schema.rb"
+    migrations_path = args[:migrations_path] || "db/migrate"
+
+    schema_diff = ActualDbSchema::SchemaDiff.new(schema_path, migrations_path)
+    puts schema_diff.render
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actual_db_schema
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.2
 platform: ruby
 authors:
 - Andrei Kaleshka
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-15 00:00:00.000000000 Z
+date: 2025-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: csv
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -149,17 +177,22 @@ files:
 - lib/actual_db_schema/commands/list.rb
 - lib/actual_db_schema/commands/rollback.rb
 - lib/actual_db_schema/configuration.rb
+- lib/actual_db_schema/console_migrations.rb
 - lib/actual_db_schema/engine.rb
 - lib/actual_db_schema/failed_migration.rb
 - lib/actual_db_schema/git.rb
 - lib/actual_db_schema/git_hooks.rb
 - lib/actual_db_schema/migration.rb
 - lib/actual_db_schema/migration_context.rb
+- lib/actual_db_schema/migration_parser.rb
 - lib/actual_db_schema/multi_tenant.rb
 - lib/actual_db_schema/output_formatter.rb
 - lib/actual_db_schema/patches/migration_context.rb
 - lib/actual_db_schema/patches/migration_proxy.rb
 - lib/actual_db_schema/patches/migrator.rb
+- lib/actual_db_schema/railtie.rb
+- lib/actual_db_schema/schema_diff.rb
+- lib/actual_db_schema/schema_parser.rb
 - lib/actual_db_schema/store.rb
 - lib/actual_db_schema/version.rb
 - lib/generators/actual_db_schema/templates/actual_db_schema.rb