migsupo 0.1.0

data/lib/migsupo/generator/migration_builder.rb

@@ -0,0 +1,185 @@
+require_relative "../differ/operations/create_table"
+require_relative "../differ/operations/drop_table"
+require_relative "../differ/operations/add_column"
+require_relative "../differ/operations/remove_column"
+require_relative "../differ/operations/change_column"
+require_relative "../differ/operations/rename_column"
+require_relative "../differ/operations/add_index"
+require_relative "../differ/operations/remove_index"
+
+module Migsupo
+  module Generator
+    class MigrationBuilder
+      def initialize(rails_version: nil)
+        @rails_version = rails_version
+      end
+
+      def build(operations, class_name:)
+        all_reversible = operations.all?(&:reversible?)
+
+        body = if all_reversible
+                 indent("def change\n#{indent(render_operations(operations))}\nend", 2)
+               else
+                 up   = indent("def up\n#{indent(render_operations(operations, direction: :up))}\nend", 2)
+                 down = indent("def down\n#{indent(render_operations(operations, direction: :down))}\nend", 2)
+                 "#{up}\n\n#{down}"
+               end
+
+        <<~RUBY
+          class #{class_name} < ActiveRecord::Migration#{version_suffix}
+          #{body}
+          end
+        RUBY
+      end
+
+      private
+
+      def version_suffix
+        return "" unless @rails_version
+
+        "[#{@rails_version}]"
+      end
+
+      def render_operations(operations, direction: :change)
+        operations.map { |op| render_operation(op, direction: direction) }.join("\n")
+      end
+
+      def render_operation(op, direction:)
+        case op
+        when Differ::Operations::CreateTable
+          render_create_table(op)
+        when Differ::Operations::DropTable
+          render_drop_table(op, direction: direction)
+        when Differ::Operations::AddColumn
+          direction == :down ? render_remove_column_from_add(op) : render_add_column(op)
+        when Differ::Operations::RemoveColumn
+          direction == :down ? render_add_column_from_remove(op) : render_remove_column(op)
+        when Differ::Operations::ChangeColumn
+          direction == :down ? render_change_column(op, column: op.old_column) : render_change_column(op, column: op.new_column)
+        when Differ::Operations::RenameColumn
+          direction == :down ? render_rename_column(op, reverse: true) : render_rename_column(op)
+        when Differ::Operations::AddIndex
+          direction == :down ? render_remove_index(op.table_name, op.index) : render_add_index(op.table_name, op.index)
+        when Differ::Operations::RemoveIndex
+          direction == :down ? render_add_index(op.table_name, op.index) : render_remove_index(op.table_name, op.index)
+        else
+          "# Unknown operation: #{op.class}"
+        end
+      end
+
+      def render_create_table(op)
+        table   = op.table
+        opts    = table_options_str(table.options.reject { |k, _| k == :force })
+        columns = table.columns.map { |col| "  #{render_column_in_table(col)}" }.join("\n")
+
+        idx_lines = table.indexes.map { |idx| render_add_index(table.name, idx) }.join("\n")
+
+        lines = ["create_table #{table.name.inspect}#{opts} do |t|"]
+        lines << collapse_timestamps(table.columns, columns)
+        lines << "end"
+        lines << idx_lines unless idx_lines.empty?
+        lines.join("\n")
+      end
+
+      def collapse_timestamps(columns, rendered)
+        col_names = columns.map(&:name)
+        if col_names.include?("created_at") && col_names.include?("updated_at")
+          created = columns.find { |c| c.name == "created_at" }
+          updated = columns.find { |c| c.name == "updated_at" }
+          if created.type == :datetime && updated.type == :datetime &&
+             created.comparable_options.empty? && updated.comparable_options.empty?
+            rendered
+              .gsub(/\s*t\.datetime :created_at[^\n]*\n/, "")
+              .gsub(/\s*t\.datetime :updated_at[^\n]*/, "")
+              .sub(/\n*$/, "\n\n  t.timestamps")
+          else
+            rendered
+          end
+        else
+          rendered
+        end
+      end
+
+      def render_drop_table(op, direction:)
+        if direction == :down
+          render_create_table(Operations::CreateTable.new(op.table))
+        else
+          "drop_table #{op.table_name.inspect}"
+        end
+      end
+
+      def render_add_column(op)
+        col  = op.column
+        opts = column_options_str(col.options)
+        "add_column #{op.table_name.inspect}, #{col.name.inspect}, :#{col.type}#{opts}"
+      end
+
+      def render_remove_column(op)
+        col  = op.column
+        opts = column_options_str(col.options.merge(type: col.type))
+        "remove_column #{op.table_name.inspect}, #{col.name.inspect}#{opts}"
+      end
+
+      def render_remove_column_from_add(op)
+        "remove_column #{op.table_name.inspect}, #{op.column.name.inspect}"
+      end
+
+      def render_add_column_from_remove(op)
+        col  = op.column
+        opts = column_options_str(col.options)
+        "add_column #{op.table_name.inspect}, #{col.name.inspect}, :#{col.type}#{opts}"
+      end
+
+      def render_change_column(op, column:)
+        opts = column_options_str(column.options)
+        "change_column #{op.table_name.inspect}, #{column.name.inspect}, :#{column.type}#{opts}"
+      end
+
+      def render_rename_column(op, reverse: false)
+        old_name = reverse ? op.new_name : op.old_name
+        new_name = reverse ? op.old_name : op.new_name
+        "rename_column #{op.table_name.inspect}, #{old_name.inspect}, #{new_name.inspect}"
+      end
+
+      def render_add_index(table_name, idx)
+        cols = idx.columns.map(&:inspect).join(", ")
+        opts = index_options_str(idx)
+        "add_index #{table_name.inspect}, [#{cols}]#{opts}"
+      end
+
+      def render_remove_index(table_name, idx)
+        "remove_index #{table_name.inspect}, name: #{idx.name.inspect}"
+      end
+
+      def render_column_in_table(col)
+        opts = column_options_str(col.options)
+        "t.#{col.type} #{col.name.inspect}#{opts}"
+      end
+
+      def column_options_str(opts)
+        return "" if opts.nil? || opts.empty?
+
+        pairs = opts.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+        ", #{pairs}"
+      end
+
+      def table_options_str(opts)
+        return "" if opts.nil? || opts.empty?
+
+        pairs = opts.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+        ", #{pairs}"
+      end
+
+      def index_options_str(idx)
+        opts = idx.comparable_options
+        opts[:name] = idx.name
+        pairs = opts.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+        ", #{pairs}"
+      end
+
+      def indent(str, spaces = 2)
+        str.lines.map { |line| line.chomp.empty? ? line : ("  " * (spaces / 2)) + line }.join
+      end
+    end
+  end
+end

data/lib/migsupo/generator/migration_generator.rb

@@ -0,0 +1,65 @@
+require_relative "naming"
+require_relative "migration_builder"
+require_relative "../differ/operations/create_table"
+require_relative "../differ/operations/drop_table"
+
+module Migsupo
+  module Generator
+    class MigrationGenerator
+      def initialize(rails_version: nil)
+        @rails_version = rails_version
+        @builder       = MigrationBuilder.new(rails_version: rails_version)
+      end
+
+      def generate(diff, output_dir:, dry_run: false)
+        return [] if diff.empty?
+
+        base_ts = base_timestamp
+        groups  = group_operations(diff.operations)
+        files   = []
+
+        groups.each_with_index do |ops, i|
+          class_name = Naming.class_name(ops)
+          timestamp  = (base_ts + i).to_s
+          file_name  = Naming.file_name(timestamp: timestamp, class_name: class_name)
+          content    = @builder.build(ops, class_name: class_name)
+
+          if dry_run
+            puts "# #{file_name}"
+            puts content
+            puts
+          else
+            file_path = File.join(output_dir, file_name)
+            File.write(file_path, content)
+            files << file_path
+          end
+        end
+
+        files
+      end
+
+      private
+
+      def group_operations(operations)
+        groups = []
+
+        create_ops = operations.select { |op| op.is_a?(Differ::Operations::CreateTable) }
+        drop_ops   = operations.select { |op| op.is_a?(Differ::Operations::DropTable) }
+        other_ops  = operations.reject { |op| op.is_a?(Differ::Operations::CreateTable) || op.is_a?(Differ::Operations::DropTable) }
+
+        create_ops.each { |op| groups << [op] }
+        drop_ops.each   { |op| groups << [op] }
+
+        other_ops.group_by(&:table_name).each_value do |ops|
+          groups << ops
+        end
+
+        groups
+      end
+
+      def base_timestamp
+        Time.now.strftime("%Y%m%d%H%M%S").to_i
+      end
+    end
+  end
+end

data/lib/migsupo/generator/naming.rb

@@ -0,0 +1,45 @@
+module Migsupo
+  module Generator
+    module Naming
+      module_function
+
+      def class_name(operations)
+        types   = operations.map(&:migration_type).uniq
+        tables  = operations.map(&:table_name).uniq
+
+        if tables.size > 1
+          "SchemaChanges"
+        elsif types == [:create_table]
+          "Create#{camelize(tables.first)}"
+        elsif types == [:drop_table]
+          "Drop#{camelize(tables.first)}"
+        elsif types.all? { |t| t == :add_column }
+          "AddColumnsTo#{camelize(tables.first)}"
+        elsif types.all? { |t| t == :remove_column }
+          "RemoveColumnsFrom#{camelize(tables.first)}"
+        elsif types.all? { |t| t == :add_index }
+          "AddIndexesTo#{camelize(tables.first)}"
+        elsif types.all? { |t| t == :remove_index }
+          "RemoveIndexesFrom#{camelize(tables.first)}"
+        else
+          "Modify#{camelize(tables.first)}"
+        end
+      end
+
+      def file_name(timestamp:, class_name:)
+        "#{timestamp}_#{underscore(class_name)}.rb"
+      end
+
+      def camelize(str)
+        str.to_s.split("_").map(&:capitalize).join
+      end
+
+      def underscore(str)
+        str.to_s
+           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .downcase
+      end
+    end
+  end
+end

data/lib/migsupo/loader/active_record_loader.rb

@@ -0,0 +1,97 @@
+require_relative "../schema/column_definition"
+require_relative "../schema/index_definition"
+require_relative "../schema/table_definition"
+require_relative "../schema/schema_definition"
+
+module Migsupo
+  module Loader
+    class ActiveRecordLoader
+      def initialize(ignored_tables: [])
+        @ignored_tables = ignored_tables
+      end
+
+      def load_schema
+        tables = {}
+
+        connection.tables.each do |table_name|
+          next if @ignored_tables.include?(table_name)
+
+          columns = load_columns(table_name)
+          indexes = load_indexes(table_name)
+          options = load_table_options(table_name)
+
+          tables[table_name] = Schema::TableDefinition.new(
+            name:    table_name,
+            columns: columns,
+            indexes: indexes,
+            options: options
+          )
+        end
+
+        Schema::SchemaDefinition.new(tables: tables)
+      end
+
+      private
+
+      def connection
+        ActiveRecord::Base.connection
+      end
+
+      def load_columns(table_name)
+        connection.columns(table_name).filter_map do |col|
+          next if col.name == "id" && primary_key_column?(table_name, col)
+
+          Schema::ColumnDefinition.new(
+            name:    col.name,
+            type:    col.type,
+            options: column_options(col)
+          )
+        end
+      end
+
+      def column_options(col)
+        opts = {}
+        opts[:null]      = col.null          unless col.null == true
+        opts[:default]   = col.default       unless col.default.nil?
+        opts[:limit]     = col.limit         if col.limit
+        opts[:precision] = col.precision     if col.precision
+        opts[:scale]     = col.scale         if col.scale
+        opts[:comment]   = col.comment       if col.respond_to?(:comment) && col.comment
+        opts
+      end
+
+      def primary_key_column?(table_name, col)
+        pk = connection.primary_key(table_name)
+        pk == col.name
+      end
+
+      def load_indexes(table_name)
+        connection.indexes(table_name).map do |idx|
+          Schema::IndexDefinition.new(
+            table_name: table_name,
+            columns:    idx.columns,
+            name:       idx.name,
+            options:    index_options(idx)
+          )
+        end
+      end
+
+      def index_options(idx)
+        opts = {}
+        opts[:unique] = true if idx.unique
+        opts[:where]  = idx.where   if idx.where
+        opts[:using]  = idx.using   if idx.using && idx.using.to_sym != :btree
+        opts
+      end
+
+      def load_table_options(table_name)
+        opts = {}
+        if connection.respond_to?(:table_comment)
+          comment = connection.table_comment(table_name)
+          opts[:comment] = comment if comment
+        end
+        opts
+      end
+    end
+  end
+end

data/lib/migsupo/loader/schema_rb_loader.rb

@@ -0,0 +1,24 @@
+require_relative "../parser/dsl_context"
+
+module Migsupo
+  module Loader
+    # Loads the current schema state from db/schema.rb without a live DB connection.
+    # db/schema.rb uses the same create_table DSL as Schemafile, so we reuse DslContext.
+    class SchemaRbLoader
+      def initialize(schema_rb_path:, ignored_tables: [])
+        @schema_rb_path = schema_rb_path
+        @ignored_tables = ignored_tables
+      end
+
+      def load_schema
+        source  = File.read(@schema_rb_path)
+        context = Parser::DslContext.new
+        context.instance_eval(source, @schema_rb_path, 1)
+        schema  = context.to_schema_definition
+
+        filtered_tables = schema.tables.reject { |name, _| @ignored_tables.include?(name) }
+        Schema::SchemaDefinition.new(tables: filtered_tables)
+      end
+    end
+  end
+end

data/lib/migsupo/parser/dsl_context.rb

@@ -0,0 +1,49 @@
+require_relative "table_dsl_context"
+require_relative "../schema/index_definition"
+require_relative "../schema/schema_definition"
+
+module Migsupo
+  module Parser
+    class DslContext
+      def initialize
+        @tables  = {}
+        @indexes = []
+      end
+
+      def create_table(name, **options, &block)
+        ctx = TableDslContext.new(name, options)
+        ctx.instance_eval(&block) if block
+        table_def = ctx.to_table_definition
+
+        # merge standalone indexes into the table definition later via SchemaDefinition
+        @tables[name.to_s] = table_def
+      end
+
+      def add_index(table_name, columns, **options)
+        @indexes << Schema::IndexDefinition.new(
+          table_name: table_name.to_s,
+          columns:    Array(columns).map(&:to_s),
+          name:       options.delete(:name),
+          options:    options
+        )
+      end
+
+      def to_schema_definition
+        tables = @tables.transform_values do |table_def|
+          standalone = @indexes.select { |i| i.table_name == table_def.name }
+          next table_def if standalone.empty?
+
+          merged_indexes = (table_def.indexes + standalone).uniq(&:name)
+          Schema::TableDefinition.new(
+            name:    table_def.name,
+            columns: table_def.columns,
+            indexes: merged_indexes,
+            options: table_def.options
+          )
+        end
+
+        Schema::SchemaDefinition.new(tables: tables)
+      end
+    end
+  end
+end

data/lib/migsupo/parser/schemafile_parser.rb

@@ -0,0 +1,18 @@
+require_relative "dsl_context"
+
+module Migsupo
+  module Parser
+    class SchemafileParser
+      def self.parse(path)
+        source = File.read(path)
+        parse_string(source, path)
+      end
+
+      def self.parse_string(source, filename = "(string)")
+        context = DslContext.new
+        context.instance_eval(source, filename, 1)
+        context.to_schema_definition
+      end
+    end
+  end
+end

data/lib/migsupo/parser/table_dsl_context.rb

@@ -0,0 +1,92 @@
+require_relative "../schema/column_definition"
+require_relative "../schema/index_definition"
+require_relative "../schema/table_definition"
+
+module Migsupo
+  module Parser
+    class TableDslContext
+      COLUMN_TYPES = %i[
+        string text integer bigint float decimal boolean
+        date datetime time timestamp binary blob json jsonb
+        uuid hstore inet cidr macaddr bit varbit
+        virtual primary_key
+      ].freeze
+
+      def initialize(table_name, options = {})
+        @table_name = table_name.to_s
+        @options    = options
+        @columns    = []
+        @indexes    = []
+      end
+
+      COLUMN_TYPES.each do |type|
+        define_method(type) do |*names, **opts|
+          names.each { |name| add_column(name, type, opts) }
+        end
+      end
+
+      def column(name, type, **opts)
+        add_column(name, type, opts)
+      end
+
+      def references(name, **opts)
+        polymorphic = opts.delete(:polymorphic)
+        index_opt   = opts.delete(:index) { true }
+        foreign_key = opts.delete(:foreign_key)
+
+        col_type = opts.delete(:type) { :bigint }
+        add_column("#{name}_id", col_type, opts)
+
+        if polymorphic
+          add_column("#{name}_type", :string, {})
+          if index_opt
+            add_index_entry([@table_name, "#{name}_type", "#{name}_id"],
+                            name: "index_#{@table_name}_on_#{name}_type_and_#{name}_id")
+          end
+        elsif index_opt
+          idx_opts = index_opt.is_a?(Hash) ? index_opt : {}
+          add_index_entry(["#{name}_id"], idx_opts)
+        end
+      end
+
+      alias belongs_to references
+
+      def timestamps(**opts)
+        precision = opts.fetch(:precision, nil)
+        col_opts  = precision ? { precision: precision } : {}
+        col_opts[:null] = opts[:null] if opts.key?(:null)
+        add_column("created_at", :datetime, col_opts)
+        add_column("updated_at", :datetime, col_opts)
+      end
+
+      def index(columns, **opts)
+        add_index_entry(Array(columns).map(&:to_s), opts)
+      end
+
+      def to_table_definition
+        Schema::TableDefinition.new(
+          name:    @table_name,
+          columns: @columns,
+          indexes: @indexes,
+          options: @options
+        )
+      end
+
+      private
+
+      def add_column(name, type, opts)
+        @columns << Schema::ColumnDefinition.new(name: name.to_s, type: type, options: opts)
+      end
+
+      def add_index_entry(columns, opts)
+        columns = columns.map(&:to_s)
+        @indexes << Schema::IndexDefinition.new(
+          table_name: @table_name,
+          columns:    columns,
+          name:       opts.delete(:name),
+          options:    opts
+        )
+      end
+    end
+  end
+end

data/lib/migsupo/railtie.rb

@@ -0,0 +1,11 @@
+require "rails/railtie"
+
+module Migsupo
+  class Railtie < Rails::Railtie
+    railtie_name :migsupo
+
+    rake_tasks do
+      load File.join(__dir__, "tasks", "migsupo.rake")
+    end
+  end
+end

data/lib/migsupo/schema/column_definition.rb

@@ -0,0 +1,42 @@
+module Migsupo
+  module Schema
+    class ColumnDefinition
+      attr_reader :name, :type, :options
+
+      COMPARABLE_OPTIONS = %i[null default limit precision scale comment].freeze
+
+      def initialize(name:, type:, options: {})
+        @name    = name.to_s
+        @type    = type.to_sym
+        @options = normalize_options(options)
+        freeze
+      end
+
+      def ==(other)
+        return false unless other.is_a?(ColumnDefinition)
+
+        name == other.name && type == other.type && comparable_options == other.comparable_options
+      end
+
+      alias eql? ==
+
+      def hash
+        [name, type, comparable_options].hash
+      end
+
+      def to_h
+        { name: name, type: type, options: options }
+      end
+
+      def comparable_options
+        options.slice(*COMPARABLE_OPTIONS).reject { |_, v| v.nil? }
+      end
+
+      private
+
+      def normalize_options(opts)
+        opts.transform_keys(&:to_sym).freeze
+      end
+    end
+  end
+end

data/lib/migsupo/schema/index_definition.rb

@@ -0,0 +1,44 @@
+module Migsupo
+  module Schema
+    class IndexDefinition
+      attr_reader :table_name, :columns, :name, :options
+
+      def initialize(table_name:, columns:, name: nil, options: {})
+        @table_name = table_name.to_s
+        @columns    = Array(columns).map(&:to_s).freeze
+        @options    = options.transform_keys(&:to_sym).freeze
+        @name       = (name || generate_name).to_s
+        freeze
+      end
+
+      def ==(other)
+        return false unless other.is_a?(IndexDefinition)
+
+        name == other.name &&
+          table_name == other.table_name &&
+          columns == other.columns &&
+          comparable_options == other.comparable_options
+      end
+
+      alias eql? ==
+
+      def hash
+        [table_name, name].hash
+      end
+
+      def to_h
+        { table_name: table_name, columns: columns, name: name, options: options }
+      end
+
+      def comparable_options
+        options.reject { |k, _| k == :name }
+      end
+
+      private
+
+      def generate_name
+        "index_#{table_name}_on_#{columns.join('_and_')}"
+      end
+    end
+  end
+end

data/lib/migsupo/schema/schema_definition.rb

@@ -0,0 +1,20 @@
+module Migsupo
+  module Schema
+    class SchemaDefinition
+      attr_reader :tables
+
+      def initialize(tables: {})
+        @tables = tables.freeze
+        freeze
+      end
+
+      def table(table_name)
+        @tables[table_name.to_s]
+      end
+
+      def to_h
+        { tables: tables.transform_values(&:to_h) }
+      end
+    end
+  end
+end