actual_db_schema 0.8.1 → 0.8.3

data/lib/actual_db_schema/schema_diff_html.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module ActualDbSchema
+  # Generates an HTML representation of the schema diff,
+  # annotated with the migrations responsible for each change.
+  class SchemaDiffHtml < SchemaDiff
+    def render_html(table_filter)
+      return unless old_schema_content && !old_schema_content.strip.empty?
+
+      @full_diff_html ||= generate_diff_html
+      filter = table_filter.to_s.strip.downcase
+
+      filter.empty? ? @full_diff_html : extract_table_section(@full_diff_html, filter)
+    end
+
+    private
+
+    def generate_diff_html
+      diff_output = generate_full_diff(old_schema_content, new_schema_content)
+      return "<pre>#{ERB::Util.html_escape(new_schema_content)}</pre>" if diff_output.strip.empty?
+
+      process_diff_output_for_html(diff_output)
+    end
+
+    def generate_full_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
+
+          `diff -u -U 9999999 #{old_file.path} #{new_file.path}`
+        end
+      end
+    end
+
+    def process_diff_output_for_html(diff_str)
+      current_table = nil
+      result_lines = []
+      @tables = {}
+      table_start = nil
+      block_depth = 1
+
+      diff_str.lines.each do |line|
+        next if line.start_with?("---") || line.start_with?("+++") || line.match(/^@@/)
+
+        current_table, table_start, block_depth =
+          process_table(line, current_table, table_start, result_lines.size, block_depth)
+        result_lines << (%w[+ -].include?(line[0]) ? handle_diff_line_html(line, current_table) : line)
+      end
+
+      result_lines.join
+    end
+
+    def process_table(line, current_table, table_start, table_end, block_depth)
+      if (ct = line.match(/create_table\s+["']([^"']+)["']/))
+        return [ct[1], table_end, block_depth]
+      end
+
+      return [current_table, table_start, block_depth] unless current_table
+
+      block_depth += line.scan(/\bdo\b/).size unless line.match(/create_table\s+["']([^"']+)["']/)
+      block_depth -= line.scan(/\bend\b/).size
+
+      if block_depth.zero?
+        @tables[current_table] = { start: table_start, end: table_end }
+        current_table = nil
+        block_depth = 1
+      end
+
+      [current_table, table_start, block_depth]
+    end
+
+    def handle_diff_line_html(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) : []
+      annotation.any? ? annotate_line(line, annotation, color) : colorize_html(line, color)
+    end
+
+    def annotate_line(line, migration_file_paths, color)
+      links_html = migration_file_paths.map { |path| link_to_migration(path) }.join(", ")
+      "#{colorize_html(line.chomp, color)}#{colorize_html(" // #{links_html} //", :gray)}\n"
+    end
+
+    def colorize_html(text, color)
+      safe = ERB::Util.html_escape(text)
+
+      case color
+      when :green
+        %(<span style="color: green">#{safe}</span>)
+      when :red
+        %(<span style="color: red">#{safe}</span>)
+      when :gray
+        %(<span style="color: gray">#{text}</span>)
+      end
+    end
+
+    def link_to_migration(migration_file_path)
+      migration = migrations.detect { |m| m.filename == migration_file_path }
+      return ERB::Util.html_escape(migration_file_path) unless migration
+
+      url = "migrations/#{migration.version}?database=#{migration.database}"
+      "<a href=\"#{url}\">#{ERB::Util.html_escape(migration_file_path)}</a>"
+    end
+
+    def migrations
+      @migrations ||= ActualDbSchema::Migration.instance.all
+    end
+
+    def extract_table_section(full_diff_html, table_name)
+      return unless @tables[table_name]
+
+      range = @tables[table_name]
+      full_diff_html.lines[range[:start]..range[:end]].join
+    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.3"
 end

data/lib/actual_db_schema.rb

@@ -10,12 +10,17 @@ 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_diff_html"
+require_relative "actual_db_schema/schema_parser"
 
 require_relative "actual_db_schema/commands/base"
 require_relative "actual_db_schema/commands/rollback"
@@ -54,7 +59,7 @@ module ActualDbSchema
   end
 
   def self.default_migrated_folder
-    Rails.root.join("tmp", "migrated")
+    config[:migrated_folder] || Rails.root.join("tmp", "migrated")
   end
 
   def self.migrations_paths

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

@@ -20,4 +20,12 @@ 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?
+
+  # Define the migrated folder location.
+  # config.migrated_folder = Rails.root.join("custom", "migrated")
+  config.migrated_folder = Rails.root.join("tmp", "migrated")
 end

data/lib/tasks/actual_db_schema.rake

@@ -53,4 +53,37 @@ 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, %i[schema_path migrations_path] => :environment 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
+
+  desc "Delete broken migration versions from the database"
+  task :delete_broken_versions, %i[versions database] => :environment do |_, args|
+    extend ActualDbSchema::OutputFormatter
+
+    if args[:versions]
+      versions = args[:versions].split(" ").map(&:strip)
+      versions.each do |version|
+        ActualDbSchema::Migration.instance.delete(version, args[:database])
+        puts colorize("[ActualDbSchema] Migration #{version} was successfully deleted.", :green)
+      rescue StandardError => e
+        puts colorize("[ActualDbSchema] Error deleting version #{version}: #{e.message}", :red)
+      end
+    elsif ActualDbSchema::Migration.instance.broken_versions.empty?
+      puts colorize("[ActualDbSchema] No broken versions found.", :gray)
+    else
+      begin
+        ActualDbSchema::Migration.instance.delete_all
+        puts colorize("[ActualDbSchema] All broken versions were successfully deleted.", :green)
+      rescue StandardError => e
+        puts colorize("[ActualDbSchema] Error deleting all broken versions: #{e.message}", :red)
+      end
+    end
+  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.3
 platform: ruby
 authors:
 - Andrei Kaleshka
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-15 00:00:00.000000000 Z
+date: 2025-03-03 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
@@ -127,12 +155,16 @@ files:
 - README.md
 - Rakefile
 - actual_db_schema.gemspec
+- app/controllers/actual_db_schema/broken_versions_controller.rb
 - app/controllers/actual_db_schema/migrations_controller.rb
 - app/controllers/actual_db_schema/phantom_migrations_controller.rb
+- app/controllers/actual_db_schema/schema_controller.rb
+- app/views/actual_db_schema/broken_versions/index.html.erb
 - app/views/actual_db_schema/migrations/index.html.erb
 - app/views/actual_db_schema/migrations/show.html.erb
 - app/views/actual_db_schema/phantom_migrations/index.html.erb
 - app/views/actual_db_schema/phantom_migrations/show.html.erb
+- app/views/actual_db_schema/schema/index.html.erb
 - app/views/actual_db_schema/shared/_js.html
 - app/views/actual_db_schema/shared/_style.html
 - config/routes.rb
@@ -149,17 +181,23 @@ 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_diff_html.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