yiffspace-fixers 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63554d772d4091d0d869023320f37c67b15f7e210ca23ef72ac99f2aaaad2fd3
-  data.tar.gz: f6466feaf844911fd1ddcdedebe1c4d9f55ff225fbce907bf1f37defc3258662
+  metadata.gz: acd62a82b8d0b1a4e8b58612b8e1fa68fa80bee2b1d32d0ec9f3dd6566aac75e
+  data.tar.gz: 87ec2fcee2b7f9259dc808f8d7a524a3e91db0c4820d7076e5d820988f2593be
 SHA512:
-  metadata.gz: 06e9bfd1da3f639d35d8d14f773a6d8d947486c8b2601aa8ac1bed4fc0746efe8f7e4f85a4d334516db6017d6c2fc3046f0c7069dc5145716ed33b1b413d49b4
-  data.tar.gz: 2b6bde7b6c07121e45cf4f4869ce0274898272fda784d653206551ab378418cb93bb2add97c3a11601b604106a99075e941598282805691cc9b189acc68edf8c
+  metadata.gz: c77170c7d1ada931e3101f9637a50b74f9cfa7306f0638642830dd318b06e71aebf31c4d8b122c38326966666511340d9871b1b7519e9807b2f09117a4b12eed
+  data.tar.gz: f2c7eae550ce7fe2039bd7c5478346bd1634848050020381ea551882fbdcff083e36eb6b2e3b05b4bec77e043fe3c7860fdaf6ece9758e22d228bfc18fa3a61d

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## Unreleased
 
+- Added `run_fix!`, the same as `run_fix` but runs fixes even if they're already applied.
+- Migrations can run fixes themselves with `run_fix(id_or_name)`, which runs and records any of
+  them not yet applied, and does nothing on rollback. `fixes:migrate_all` reads these calls out
+  of pending migrations and folds those fixes into the migration's step instead of scheduling
+  them separately. A fix run this way can `requires_migration!` the migration running it.
 - Fixes run through `YiffSpace::FixTracker.run!` (so every `fixes:*` task) can call
   `requires_migration!` unqualified, via `YiffSpace::Fixers::Script` - each fix is now loaded
   wrapped in its own module including it, rather than straight into the top level, so it isn't

data/README.md

@@ -49,6 +49,21 @@ class RemoveLegacyWidgetColumn < ActiveRecord::Migration[8.1]
 end
 ```
 
+A migration can also run a fix itself with `run_fix`, inside its own transaction - skipped if the
+fix is already applied, and when the migration is rolled back. `fixes:migrate_all` leaves those
+fixes to the migration rather than running them on their own, and a fix run this way can
+`requires_migration!` the migration running it. `run_fix!` does the same, but runs the fix even if
+it's already applied:
+
+```ruby
+class AddWidgetType < ActiveRecord::Migration[8.1]
+  def change
+    add_column(:widgets, :type, :string)
+    run_fix(12)
+  end
+end
+```
+
 See `YiffSpace::FixTracker`, `YiffSpace::FixerTemplate`, `YiffSpace::Fixers::RequiresFix`, and
 `YiffSpace::MigrationSync` for the full API.
 

data/lib/yiffspace/fix_tracker.rb

@@ -27,7 +27,7 @@ module YiffSpace
     end
 
     def requires_migration!(version)
-      return if migration_applied?(version)
+      return if migration_applied?(version) || migration_running?(version)
 
       raise(MigrationRequired, "migration #{version} must be applied before this fix can run")
     end
@@ -36,6 +36,23 @@ module YiffSpace
       migration_context.get_all_versions.include?(version.to_i)
     end
 
+    # A migration isn't recorded as applied until it finishes, so a fix it runs with
+    # YiffSpace::Fixers::RequiresFix#run_fix is let through requires_migration! for it via this.
+    def running_migration(version)
+      running_migrations << version.to_i
+      yield
+    ensure
+      running_migrations.pop
+    end
+
+    def migration_running?(version)
+      running_migrations.include?(version.to_i)
+    end
+
+    def running_migrations
+      @running_migrations ||= []
+    end
+
     # Statically reads a fix script's declared requires_migration! version, if any, without
     # loading/running it - nil if the fix has no such call.
     def required_migration_for(name)

data/lib/yiffspace/fixers/requires_fix.rb

@@ -18,10 +18,32 @@ module YiffSpace
     # out of order), and read back ahead of time by YiffSpace::MigrationSync to order
     # `fixes:migrate_all` correctly. Included into ActiveRecord::Migration by
     # YiffSpace::Fixers::Engine.
+    #
+    # A migration can also run a fix itself, as part of migrating, with `run_fix`:
+    #
+    #   def change
+    #     add_column(:widgets, :type, :string)
+    #     run_fix(3)
+    #   end
+    #
+    # Each fix it covers is run and recorded the same as YiffSpace::FixTracker.run!, unless it's
+    # already applied, and inside the migration's transaction. Fixes can't be undone, so it does
+    # nothing when the migration is rolled back. A fix run this way can requires_migration! the
+    # migration running it. `run_fix!` does the same, but runs fixes even if already applied.
     module RequiresFix
       # Raised when a migration runs before one of its required fixes has been applied.
       class FixRequired < StandardError; end
 
+      # Same idea as YiffSpace::FixTracker::REQUIRES_MIGRATION_PATTERN - lets
+      # YiffSpace::MigrationSync read the fixes a migration runs out of its file, so
+      # `fixes:migrate_all` leaves them to the migration instead of running them on their own.
+      RUN_FIX_PATTERN = /^\s*run_fix!?\(\s*(?:(\d+)|["']([^"']+)["'])\s*\)/
+
+      # The id_or_name of every run_fix/run_fix! call in a migration file.
+      def self.fixes_run_by(path)
+        File.read(path).scan(RUN_FIX_PATTERN).map { |id, name| id ? id.to_i : name }
+      end
+
       def self.included(base)
         base.extend(ClassMethods)
         base.prepend(InstanceMethods)
@@ -46,8 +68,35 @@ module YiffSpace
           super
         end
 
+        # id_or_name: same as requires_fix.
+        def run_fix(id_or_name)
+          run_fixes(id_or_name, force: false)
+        end
+
+        # Same as run_fix, but runs fixes even if they're already applied.
+        def run_fix!(id_or_name)
+          run_fixes(id_or_name, force: true)
+        end
+
         private
 
+        def run_fixes(id_or_name, force:)
+          return if reverting?
+
+          names = YiffSpace::FixTracker.resolve(id_or_name)
+          raise(ArgumentError, "#{self.class.name} runs fix #{id_or_name.inspect}, which does not exist") if names.empty?
+
+          names.each do |name|
+            if !force && YiffSpace::FixTracker.applied?(name)
+              say("#{name} already applied, skipping")
+            else
+              say_with_time("run_fix#{'!' if force}(#{name.inspect})") do
+                YiffSpace::FixTracker.running_migration(version) { YiffSpace::FixTracker.run!(YiffSpace::FixTracker.fix_path(name)) }
+              end
+            end
+          end
+        end
+
         def check_required_fixes!
           self.class.required_fixes.each do |id_or_name|
             names = YiffSpace::FixTracker.resolve(id_or_name)

data/lib/yiffspace/fixers/version.rb

@@ -2,6 +2,6 @@
 
 module YiffSpace
   module Fixers
-    VERSION = "0.0.3"
+    VERSION = "0.0.5"
   end
 end

data/lib/yiffspace/migration_sync.rb

@@ -4,8 +4,9 @@ module YiffSpace
   # Computes and applies pending db/migrate/*.rb migrations and db/fixes/*.rb fixes together, in
   # whichever order their cross requirements demand - a fix can require a migration
   # (YiffSpace::FixTracker.requires_migration!) and a migration can require a fix
-  # (YiffSpace::Fixers::RequiresFix#requires_fix). Migrations stay ordered among themselves by
-  # version, fixes among themselves by YiffSpace::FixTracker.sort_key, and those cross
+  # (YiffSpace::Fixers::RequiresFix#requires_fix), or run it itself (RequiresFix#run_fix).
+  # Migrations stay ordered among themselves by version, fixes among themselves by
+  # YiffSpace::FixTracker.sort_key, and those cross
   # requirements are woven in via a topological sort. #plan/#apply are used by `rake
   # fixes:migrate_all` (see lib/tasks/fixes.rake).
   module MigrationSync
@@ -24,15 +25,22 @@ module YiffSpace
     def plan
       migrations = pending_migrations
       fixes = FixTracker.pending
+      run_by = fixes_run_by(migrations)
 
       steps = {}
       migrations.each { |m| steps[[:migration, m.version]] = Step.new(:migration, m, [:migration, m.version]) }
-      fixes.each { |f| steps[[:fix, f]] = Step.new(:fix, f, [:fix, f]) }
+      fixes.each { |f| steps[[:fix, f]] = Step.new(:fix, f, [:fix, f]) unless run_by.key?([:fix, f]) }
 
       edges = Hash.new { |h, k| h[k] = [] }
       indegree = steps.each_key.index_with(0)
 
       link = lambda do |before, after|
+        # A fix a migration runs (see #fixes_run_by) has no step of its own, its requirements and
+        # ordering carry over to that migration instead. One requiring that same migration links
+        # it to itself, which needs nothing - FixTracker.running_migration covers it at runtime.
+        before = run_by.fetch(before, before)
+        after = run_by.fetch(after, after)
+        next if before == after
         next unless steps.key?(before) && steps.key?(after)
 
         edges[before] << after
@@ -70,6 +78,19 @@ module YiffSpace
       end
     end
 
+    # Maps [:fix, name] => [:migration, version] for every pending fix a pending migration runs
+    # itself with YiffSpace::Fixers::RequiresFix#run_fix.
+    def fixes_run_by(migrations)
+      migrations.each_with_object({}) do |m, run_by|
+        Fixers::RequiresFix.fixes_run_by(m.filename).each do |id_or_name|
+          names = FixTracker.resolve(id_or_name)
+          raise(UnresolvableOrder, "#{m.name} runs fix #{id_or_name.inspect}, which does not exist") if names.empty?
+
+          names.each { |name| run_by[[:fix, name]] ||= [:migration, m.version] }
+        end
+      end
+    end
+
     # Kahn's algorithm - ready nodes are processed FIFO in `steps`' insertion order (migrations
     # before fixes when both are ready at once), so requirements only ever reorder things when
     # they actually have to.

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: yiffspace-fixers
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Donovan_DMC
 bindir: bin
 cert_chain: []
-date: 2026-10-03 00:00:00.000000000 Z
+date: 2026-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails