tina4ruby 0.5.2 → 3.0.0

data/lib/tina4/migration.rb

@@ -3,41 +3,54 @@ require "fileutils"
 
 module Tina4
   class Migration
-    TRACKING_TABLE = "tina4_migrations"
+    TRACKING_TABLE = "tina4_migration"
+
+    attr_reader :db, :migrations_dir
 
     def initialize(db, migrations_dir: nil)
       @db = db
-      @migrations_dir = migrations_dir || File.join(Dir.pwd, "migrations")
+      @migrations_dir = migrations_dir || File.join(Dir.pwd, "src", "migrations")
       ensure_tracking_table
     end
 
-    def run
+    # Run all pending migrations
+    def migrate
       pending = pending_migrations
       if pending.empty?
-        Tina4::Debug.info("No pending migrations")
+        Tina4::Log.info("No pending migrations")
         return []
       end
 
+      batch = next_batch_number
       results = []
       pending.each do |file|
-        result = run_migration(file)
+        result = run_migration(file, batch)
         results << result
+        # Stop on failure
+        break if result[:status] == "failed"
       end
       results
     end
 
+    alias run migrate
+
+    # Rollback last batch (or N steps)
     def rollback(steps = 1)
-      completed = completed_migrations.last(steps)
-      completed.reverse.each do |name|
-        down_file = File.join(@migrations_dir, name.sub(".sql", ".down.sql"))
-        if File.exist?(down_file)
-          execute_sql_file(down_file)
-          remove_migration_record(name)
-          Tina4::Debug.info("Rolled back: #{name}")
-        else
-          Tina4::Debug.warning("No rollback file for: #{name}")
-        end
+      completed = completed_migrations_with_batch
+      return [] if completed.empty?
+
+      # Get the last N unique batches
+      batches = completed.map { |m| m[:batch] }.uniq.sort.reverse
+      batches_to_rollback = batches.first(steps)
+
+      results = []
+      completed.select { |m| batches_to_rollback.include?(m[:batch]) }
+               .sort_by { |m| -m[:id] }
+               .each do |migration|
+        result = rollback_migration(migration[:migration_name])
+        results << result
       end
+      results
     end
 
     def status
@@ -47,17 +60,30 @@ module Tina4
       }
     end
 
+    # Create a new migration file
     def create(name)
       FileUtils.mkdir_p(@migrations_dir)
       timestamp = Time.now.strftime("%Y%m%d%H%M%S")
-      filename = "#{timestamp}_#{name.gsub(/\s+/, '_')}.sql"
+      filename = "#{timestamp}_#{name.gsub(/\s+/, '_')}.rb"
       filepath = File.join(@migrations_dir, filename)
-      File.write(filepath, "-- Migration: #{name}\n-- Created: #{Time.now}\n\n")
 
-      down_filepath = filepath.sub(".sql", ".down.sql")
-      File.write(down_filepath, "-- Rollback: #{name}\n-- Created: #{Time.now}\n\n")
+      File.write(filepath, <<~RUBY)
+        # frozen_string_literal: true
+        # Migration: #{name}
+        # Created: #{Time.now}
+
+        class #{classify(name)} < Tina4::MigrationBase
+          def up(db)
+            # db.exec("CREATE TABLE ...")
+          end
 
-      Tina4::Debug.info("Created migration: #{filename}")
+          def down(db)
+            # db.exec("DROP TABLE IF EXISTS ...")
+          end
+        end
+      RUBY
+
+      Tina4::Log.info("Created migration: #{filename}")
       filepath
     end
 
@@ -69,10 +95,11 @@ module Tina4
           CREATE TABLE #{TRACKING_TABLE} (
             id INTEGER PRIMARY KEY,
             migration_name VARCHAR(255) NOT NULL,
+            batch INTEGER NOT NULL DEFAULT 1,
             executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
           )
         SQL
-        Tina4::Debug.info("Created migrations tracking table")
+        Tina4::Log.info("Created migrations tracking table")
       end
     end
 
@@ -81,29 +108,79 @@ module Tina4
       result.map { |r| r[:migration_name] }
     end
 
+    def completed_migrations_with_batch
+      result = @db.fetch("SELECT id, migration_name, batch FROM #{TRACKING_TABLE} ORDER BY id")
+      result.map { |r| { id: r[:id], migration_name: r[:migration_name], batch: r[:batch] } }
+    end
+
+    def next_batch_number
+      result = @db.fetch_one("SELECT MAX(batch) as max_batch FROM #{TRACKING_TABLE}")
+      (result && result[:max_batch] ? result[:max_batch].to_i : 0) + 1
+    end
+
     def pending_migrations
       return [] unless Dir.exist?(@migrations_dir)
 
       completed = completed_migrations
-      Dir.glob(File.join(@migrations_dir, "*.sql"))
+      # Support both .rb and .sql migration files
+      Dir.glob(File.join(@migrations_dir, "*.{rb,sql}"))
          .reject { |f| f.end_with?(".down.sql") }
          .sort
          .reject { |f| completed.include?(File.basename(f)) }
     end
 
-    def run_migration(file)
+    def run_migration(file, batch)
       name = File.basename(file)
-      Tina4::Debug.info("Running migration: #{name}")
+      Tina4::Log.info("Running migration: #{name}")
       begin
-        execute_sql_file(file)
-        record_migration(name)
+        if file.end_with?(".rb")
+          execute_ruby_migration(file, :up)
+        else
+          execute_sql_file(file)
+        end
+        record_migration(name, batch)
         { name: name, status: "success" }
       rescue => e
-        Tina4::Debug.error("Migration failed: #{name} - #{e.message}")
+        Tina4::Log.error("Migration failed: #{name} - #{e.message}")
         { name: name, status: "failed", error: e.message }
       end
     end
 
+    def rollback_migration(name)
+      Tina4::Log.info("Rolling back: #{name}")
+      begin
+        file = File.join(@migrations_dir, name)
+        if name.end_with?(".rb") && File.exist?(file)
+          execute_ruby_migration(file, :down)
+        elsif name.end_with?(".sql")
+          down_file = File.join(@migrations_dir, name.sub(".sql", ".down.sql"))
+          if File.exist?(down_file)
+            execute_sql_file(down_file)
+          else
+            Tina4::Log.warning("No rollback file for: #{name}")
+          end
+        end
+        remove_migration_record(name)
+        { name: name, status: "rolled_back" }
+      rescue => e
+        Tina4::Log.error("Rollback failed: #{name} - #{e.message}")
+        { name: name, status: "failed", error: e.message }
+      end
+    end
+
+    def execute_ruby_migration(file, direction)
+      # Load the migration class
+      content = File.read(file)
+      # Evaluate in a clean binding
+      eval(content, TOPLEVEL_BINDING, file)
+
+      # Find the migration class (last class defined that inherits from MigrationBase)
+      class_name = extract_class_name(content)
+      klass = Object.const_get(class_name)
+      migration = klass.new
+      migration.__send__(direction, @db)
+    end
+
     def execute_sql_file(file)
       sql = File.read(file)
       statements = sql.split(";").map(&:strip).reject(&:empty?)
@@ -113,12 +190,38 @@ module Tina4
       end
     end
 
-    def record_migration(name)
-      @db.insert(TRACKING_TABLE, { migration_name: name })
+    def record_migration(name, batch)
+      @db.insert(TRACKING_TABLE, { migration_name: name, batch: batch })
     end
 
     def remove_migration_record(name)
       @db.delete(TRACKING_TABLE, { migration_name: name })
     end
+
+    def classify(name)
+      name.gsub(/[^a-zA-Z0-9_]/, "_")
+          .split("_")
+          .map(&:capitalize)
+          .join
+    end
+
+    def extract_class_name(content)
+      if content =~ /class\s+(\w+)\s*<\s*Tina4::MigrationBase/
+        $1
+      else
+        raise "No migration class found inheriting from Tina4::MigrationBase"
+      end
+    end
+  end
+
+  # Base class for Ruby migrations
+  class MigrationBase
+    def up(db)
+      raise NotImplementedError, "Implement #up in your migration"
+    end
+
+    def down(db)
+      raise NotImplementedError, "Implement #down in your migration"
+    end
   end
 end