decidim-core 0.29.2 → 0.30.0.rc1

data/lib/decidim/seeds.rb

@@ -21,7 +21,7 @@ module Decidim
       user = Decidim::User.find_or_initialize_by(email:)
       user.update!(
         name: ::Faker::Name.name,
-        nickname: ::Faker::Twitter.unique.screen_name,
+        nickname: "#{::Faker::Twitter.unique.screen_name}-#{rand(10_000)}"[0...20],
         password: "decidim123456789",
         organization:,
         confirmed_at: Time.current,
@@ -38,18 +38,6 @@ module Decidim
       user
     end
 
-    def random_scope(participatory_space:)
-      if participatory_space.scope
-        scopes = participatory_space.scope.descendants
-        global = participatory_space.scope
-      else
-        scopes = participatory_space.organization.scopes
-        global = nil
-      end
-
-      ::Faker::Boolean.boolean(true_ratio: 0.5) ? global : scopes.sample
-    end
-
     def seeds_root = File.join(__dir__, "..", "..", "db", "seeds")
 
     def hero_image = create_blob!(seeds_file: "city.jpeg", filename: "hero_image.jpeg", content_type: "image/jpeg")
@@ -97,13 +85,23 @@ module Decidim
       )
     end
 
-    def create_category!(participatory_space:)
-      Decidim::Category.create!(
-        name: Decidim::Faker::Localized.sentence(word_count: 5),
-        description: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
-          Decidim::Faker::Localized.paragraph(sentence_count: 3)
-        end,
-        participatory_space:
+    def create_taxonomy!(name:, parent:)
+      Decidim::Taxonomy.create!(
+        name: Decidim::Faker::Localized.literal(name),
+        organization:,
+        parent:
+      )
+    end
+
+    def create_taxonomy_filter!(root_taxonomy:, taxonomies:, participatory_space_manifests: [])
+      Decidim::TaxonomyFilter.create!(
+        root_taxonomy:,
+        participatory_space_manifests:,
+        filter_items: taxonomies.map do |taxonomy_item|
+          Decidim::TaxonomyFilterItem.new(
+            taxonomy_item:
+          )
+        end
       )
     end
 

data/lib/decidim/settings_manifest.rb

@@ -70,6 +70,8 @@ module Decidim
             validates name, presence: true if attribute.required
             validates name, inclusion: { in: attribute.build_choices } if attribute.type == :enum
           end
+
+          SettingsManifest.add_integer_with_units_validation(self, name, attribute) if attribute.type == :integer_with_units
         end
       end
 
@@ -77,6 +79,20 @@ module Decidim
       @schema
     end
 
+    def self.add_integer_with_units_validation(schema, name, attribute)
+      schema.class_eval do
+        validate do
+          value = send(name)
+          value = [value["0"].to_i, value["1"].to_s] if value.is_a?(::Hash)
+
+          errors.add(name, :invalid) unless value.is_a?(::Array) &&
+                                            value.size == 2 &&
+                                            value[0].is_a?(Integer) &&
+                                            attribute.build_units.include?(value[1])
+        end
+      end
+    end
+
     def required_attributes_for_authorization
       attributes.select { |_, attribute| attribute.required_for_authorization? }
     end
@@ -91,6 +107,7 @@ module Decidim
       TYPES = {
         boolean: { klass: Boolean, default: false },
         integer: { klass: Integer, default: 0 },
+        integer_with_units: { klass: Decidim::Attributes::IntegerWithUnits, default: [5, "minutes"] },
         string: { klass: String, default: nil },
         float: { klass: Float, default: nil },
         text: { klass: String, default: nil },
@@ -98,7 +115,8 @@ module Decidim
         enum: { klass: String, default: nil },
         select: { klass: String, default: nil },
         scope: { klass: Integer, default: nil },
-        time: { klass: Decidim::Attributes::TimeWithZone, default: nil }
+        time: { klass: Decidim::Attributes::TimeWithZone, default: nil },
+        taxonomy_filters: { klass: Array, default: [] }
       }.freeze
 
       attribute :type, Symbol, default: :boolean
@@ -111,9 +129,20 @@ module Decidim
       attribute :required_for_authorization, Boolean, default: false
       attribute :readonly
       attribute :choices
+      attribute :units
       attribute :include_blank, Boolean, default: false
 
       validates :type, inclusion: { in: TYPES.keys }
+      validate :validate_integer_with_units_structure
+
+      def validate_integer_with_units_structure
+        return unless type == :integer_with_units
+
+        errors.add(:default, :invalid) unless default_value.is_a?(::Array) &&
+                                              default_value.size == 2 &&
+                                              default_value[0].is_a?(Integer) &&
+                                              build_units.include?(default_value[1])
+      end
 
       def type_class
         return Decidim::Attributes::RichText if type == :text && editor == true
@@ -129,6 +158,10 @@ module Decidim
         choices.try(:call) || choices
       end
 
+      def build_units
+        units.try(:call) || units
+      end
+
       def readonly?(context)
         readonly&.call(context)
       end

data/lib/decidim/soft_deletable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "paranoia"
+
+module Decidim
+  # This concern contains the logic related to soft deletion (trashing).
+  module SoftDeletable
+    extend ActiveSupport::Concern
+
+    included do
+      acts_as_paranoid
+
+      scope :deleted_at_desc, -> { order(deleted_at: :desc) }
+    end
+  end
+end

data/lib/decidim/taxonomizable.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # A concern with the components needed when you want a model to have taxonomies.
+  #
+  # The including model needs to implement the following interface:
+  #
+  #  @abstract  method that gives an associated organization
+  #  @method organization
+  #    @return [Decidim::Organization]
+  #
+  module Taxonomizable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :taxonomizations, as: :taxonomizable, class_name: "Decidim::Taxonomization", dependent: :destroy
+      has_many :taxonomies, through: :taxonomizations
+
+      validate :no_root_taxonomies
+      validate :taxonomies_belong_to_organization
+
+      # finds taxonomizables belonging to a specific taxonomy
+      scope :with_taxonomy, ->(taxonomy_id) { includes(:taxonomies).references(:decidim_taxonomies).where("? = ANY(decidim_taxonomies.part_of)", taxonomy_id) }
+
+      # finds taxonomizables belonging to any of the taxonomies specified (or its children)
+      scope :with_taxonomies, lambda { |*taxonomy_ids|
+        conditions = ["? = ANY(part_of)"] * taxonomy_ids.count
+        taxonomies = Decidim::Taxonomy.where(conditions.join(" OR "), *taxonomy_ids.map(&:to_i))
+        includes(:taxonomies).joins(:taxonomies).where(decidim_taxonomies: { id: taxonomies })
+      }
+
+      # finds taxonomizables belonging to all groups of taxonomies specified, each group is an array of taxonomy ids that are ORed together
+      scope :with_any_taxonomies, lambda { |*taxonomy_groups|
+        return with_taxonomies(*taxonomy_groups) unless taxonomy_groups.first.is_a?(Array)
+
+        queries = []
+        taxonomy_groups.each do |root_id, taxonomy_ids|
+          taxonomy_ids = taxonomy_ids.flatten.compact_blank
+          next if taxonomy_ids.empty?
+
+          taxonomy_ids = [root_id] if taxonomy_ids.include?("all")
+
+          queries << with_taxonomies(*taxonomy_ids)
+        end
+        return self if queries.empty?
+        return queries.first if queries.count == 1
+
+        subquery = queries.map(&:arel).reduce do |memo, query|
+          Arel::Nodes::Intersect.new(memo, query)
+        end
+
+        @klass.from(Arel::Nodes::As.new(subquery, Arel.sql(@klass.arel_table.name)))
+      }
+
+      private
+
+      def no_root_taxonomies
+        return unless taxonomies.any?(&:root?)
+
+        errors.add(:taxonomies, :invalid)
+      end
+
+      def taxonomies_belong_to_organization
+        return if taxonomies.all? { |taxonomy| taxonomy.organization == organization }
+
+        errors.add(:taxonomies, :invalid)
+      end
+    end
+  end
+end

data/lib/decidim/view_model.rb

@@ -8,7 +8,6 @@ module Decidim
     include ActionView::Helpers::TranslationHelper
     include ::Cell::Translation
     include Decidim::ResourceHelper
-    include Decidim::ScopesHelper
     include ActionController::Helpers
     include Decidim::ActionAuthorization
     include Decidim::ActionAuthorizationHelper

data/lib/tasks/decidim_download_your_data_tasks.rake

@@ -64,7 +64,7 @@ namespace :decidim do
     input = $stdin.gets.chomp
     if input.casecmp("y").zero?
       puts %(  Continue...)
-      Decidim::User.where("newsletter_notifications_at < ?", Time.zone.parse("2018-05-25 00:00 +02:00")).find_each(&:newsletter_opt_in_notify)
+      Decidim::User.where(newsletter_notifications_at: ...Time.zone.parse("2018-05-25 00:00 +02:00")).find_each(&:newsletter_opt_in_notify)
     else
       puts %(  Execution cancelled...)
     end
@@ -76,9 +76,7 @@ namespace :decidim do
     attachments = ActiveStorage::Attachment.joins(:blob).where(
       name: "download_your_data_file",
       record_type: "Decidim::UserBaseEntity"
-    ).where(
-      "active_storage_blobs.created_at < ?", Decidim.download_your_data_expiry_time.ago
-    )
+    ).where(active_storage_blobs: { created_at: ...Decidim.download_your_data_expiry_time.ago })
     attachments.each do |attachment|
       delete_download_your_data_file attachment
     end

data/lib/tasks/decidim_procfile.rake

@@ -11,6 +11,12 @@ namespace :decidim do
         shakapacker: bin/shakapacker-dev-server
       RUBY
 
+      if defined?(Sidekiq)
+        actions :append_file, "Procfile.dev", <<~RUBY
+          sidekiq: bundle exec sidekiq -C config/sidekiq.yml
+        RUBY
+      end
+
       actions :create_file, "bin/dev", %(#!/usr/bin/env sh
 
 set -e

data/lib/tasks/decidim_tasks.rake

@@ -6,6 +6,7 @@ namespace :decidim do
     :choose_target_plugins,
     :"decidim:upgrade_app",
     :"railties:install:migrations",
+    :"decidim:upgrade:migrations",
     :"decidim:upgrade:webpacker",
     :"decidim_api:generate_docs"
   ]

data/lib/tasks/decidim_taxonomies.rake

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "decidim/maintenance"
+
+namespace :decidim do
+  namespace :taxonomies do
+    desc "Creates a JSON file with the taxonomies structure imported from older models"
+    task :make_plan, [] => :environment do |_task, _args|
+      Decidim::Organization.find_each do |organization|
+        log(true).info "Creating a plan for organization #{organization.id} in #{plan_file_path(organization)}"
+        FileUtils.mkdir_p(Rails.root.join("tmp/taxonomies"))
+        json = planner(organization).to_json do |model|
+          log.info "...Exporting taxonomies for #{model.table_name}"
+        end
+        File.write(plan_file_path(organization), json)
+        log.info "Plan created, you can review or edit if needed before importing."
+        log.info "Import the plan with this command:"
+        log.info "bin/rails decidim:taxonomies:import_plan[#{plan_file_path(organization)}]"
+      end
+    end
+
+    desc "Imports taxonomies and filters structure from a JSON file"
+    task :import_plan, [:file] => :environment do |_task, args|
+      file = args[:file].to_s
+      abort "File not found! [#{file}]" unless File.exist?(file)
+
+      data = JSON.parse(File.read(file))
+      organization = Decidim::Organization.find_by(id: data.dig("organization", "id"))
+      abort "Organization not found! [#{data["organization"]}]" unless organization
+      log(true).info "Importing taxonomies and filters for organization #{organization.id}"
+
+      planner(organization).import(data) do |importer, model_name|
+        taxonomies = importer.roots
+        result = importer.result
+        log.info "...Importing #{taxonomies.count} root taxonomies from #{model_name}"
+        taxonomies.each do |name, taxonomy|
+          log.info "  - Root taxonomy: #{name}"
+          log.info "    1st level taxonomies: #{taxonomy["taxonomies"].count}"
+          log.info "    Filters: #{taxonomy["filters"].count}"
+          taxonomy["filters"].each do |filter|
+            log.info "      - Filter name: #{filter["name"]}"
+            log.info "        Internal name: #{filter["internal_name"] || "-"}"
+            log.info "        Space manifests: #{filter["participatory_space_manifests"]&.join(", ") || "-"}"
+            log.info "        Items: #{filter["items"].count}"
+            log.info "        Components: #{filter["components"].count}"
+          end
+        end
+        importer.import! do |type, detail|
+          log.info "    !#{type}: #{detail}"
+        end
+        log.info "    Created taxonomies: #{result[:taxonomies_created].count}"
+        result[:taxonomies_created].each do |name|
+          log.info "      - #{name}"
+        end
+        log.info "    Created filters: #{result[:filters_created].count}"
+        result[:filters_created].each do |name, items|
+          log.info "      - #{name}: #{items.count} items"
+        end
+        log.info "    Assigned resources: #{result[:taxonomies_assigned].count}"
+        result[:taxonomies_assigned].each do |name, items|
+          log.info "      - #{name}: #{items.count} resources"
+        end
+        log.info "    Assigned components: #{result[:components_assigned].count}"
+        result[:components_assigned].each do |name, items|
+          log.info "      - #{name}: #{items.count} components"
+        end
+        log.info "    Failed resources: #{result[:failed_resources].count}"
+        result[:failed_resources].each do |object_id|
+          log.info "      - #{object_id}"
+        end
+        log.info "    Failed components: #{result[:failed_components].count}"
+        result[:failed_components].each do |component_id|
+          log.info "      - #{component_id}"
+        end
+        Rails.root.join("tmp/taxonomies", "#{organization.host}_result.json").write(JSON.pretty_generate(result))
+        log.info "Result saved in tmp/taxonomies/#{organization.host}_result.json"
+      end
+      log.info "Taxonomies and filters imported successfully."
+    end
+
+    desc "Imports taxonomies and filters structure from all JSON files inside tmp/taxonomies"
+    task :import_all_plans, [] => :environment do |_task, _args|
+      Rails.root.glob("tmp/taxonomies/*_plan.json").each do |file|
+        log.info "Importing plan from #{file}"
+        Rake::Task["decidim:taxonomies:import_plan"].invoke(file)
+      end
+    end
+
+    desc "Adds taxonomies to metrics from old categories"
+    task :update_metrics, [:file] => :environment do |_task, args|
+      file = args[:file].to_s
+      abort "File not found! [#{file}]" unless File.exist?(file)
+
+      data = JSON.parse(File.read(file))
+      taxonomies = data["taxonomy_map"]
+      abort "No taxonomies found in the file" unless taxonomies && taxonomies&.any?
+
+      total = taxonomies.count
+      taxonomies.each_with_index do |(id, object_id), index|
+        next unless object_id.include?("ImportModels::Category")
+
+        category_id = object_id.split("/").last
+        percent = ((index + 1) * 100 / total).to_i
+
+        count = Decidim::Metric.where(decidim_category_id: category_id).count
+        log.info "...#{percent}% Updating #{count} metrics for category #{category_id} to taxonomy #{id}"
+        Decidim::Metric.where(decidim_category_id: category_id).update_all(decidim_taxonomy_id: id) # rubocop:disable Rails/SkipsModelValidations
+      end
+    end
+
+    desc "Processes all metrics for result files in tmp/taxonomies"
+    task :update_all_metrics, [] => :environment do |_task, _args|
+      Rails.root.glob("tmp/taxonomies/*_result.json").each do |file|
+        log.info "Processing metrics from #{file}"
+        Rake::Task["decidim:taxonomies:update_metrics"].invoke(file)
+      end
+    end
+
+    desc "Reset counters for taxonomies and taxonomy filters"
+    task :reset_counters, [] => :environment do |_task, _args|
+      Decidim::Taxonomy.find_each do |taxonomy|
+        taxonomy.reset_all_counters
+        log.info "Counters reset for taxonomy #{taxonomy.id}:"
+        log.info "  Children: #{taxonomy.children_count}"
+        log.info "  Taxonomizations: #{taxonomy.taxonomizations_count}"
+        log.info "  Filters: #{taxonomy.filters_count}"
+        log.info "  Filter items: #{taxonomy.filter_items_count}"
+      end
+      Decidim::TaxonomyFilter.find_each do |filter|
+        filter.reset_all_counters
+        log.info "Counters reset for taxonomy filter #{filter.id}:"
+        log.info "  Filter items: #{filter.filter_items_count}"
+        log.info "  Components: #{filter.components_count}"
+      end
+    end
+
+    def planner(organization)
+      models = ENV.fetch("IMPORTS", "ParticipatoryProcessType AssemblyType Scope Area Category").split.map do |model_name|
+        "Decidim::Maintenance::ImportModels::#{model_name}".constantize
+      end
+      Decidim::Maintenance::TaxonomyPlan.new(organization, models)
+    end
+
+    def plan_file_path(organization)
+      Rails.root.join("tmp/taxonomies", "#{organization.host}_plan.json")
+    end
+
+    def log(reset = false) # rubocop:disable Style/OptionalBooleanParameter
+      @log = nil if reset
+      @log ||= Logger.new($stdout, formatter: proc { |_severity, _time, _progname, msg|
+        "#{msg}\n"
+      })
+    end
+  end
+end

data/lib/tasks/upgrade/{decidim_fix_categorization.rake → clean.rake}

@@ -8,6 +8,7 @@ namespace :decidim do
         :"decidim:upgrade:clean:searchable_resources",
         :"decidim:upgrade:clean:notifications",
         :"decidim:upgrade:clean:follows",
+        :"decidim:upgrade:clean:categories",
         :"decidim:upgrade:clean:action_logs",
         :"decidim:upgrade:clean:clean_deleted_users",
         :"decidim:upgrade:clean:fix_blocked_user_notification"
@@ -15,14 +16,13 @@ namespace :decidim do
 
       desc "Remove data from deleted users"
       task clean_deleted_users: :environment do
-        logger = Logger.new($stdout)
         logger.info("=== Removing extra data from deleted users")
         Decidim::User.where.not(deleted_at: nil).update_all(personal_url: "", about: "", notifications_sending_frequency: "none") # rubocop:disable Rails/SkipsModelValidations
       end
 
       desc "Removes any action logs belonging to invalid resources"
       task :action_logs, [] => :environment do
-        puts "=== Deleting Action logs\n"
+        logger.info("=== Deleting Action logs")
         invalid = 0
         Decidim::ActionLog.find_each do |log|
           log.participatory_space if log.participatory_space_type.present?
@@ -42,12 +42,12 @@ namespace :decidim do
           log.delete
           invalid += 1
         end
-        puts "===== Deleted #{invalid} invalid action logs\n"
+        logger.info("===== Deleted #{invalid} invalid action logs")
       end
 
       desc "Removes any follows belonging to invalid resources"
       task :follows, [] => :environment do
-        puts "=== Deleting Follows\n"
+        logger.info("=== Deleting Follows")
         invalid = 0
         Decidim::Follow.find_each do |follow|
           follow.followable
@@ -63,12 +63,12 @@ namespace :decidim do
           follow.delete
           invalid += 1
         end
-        puts "===== Deleted #{invalid} invalid follows\n"
+        logger.info("===== Deleted #{invalid} invalid follows")
       end
 
       desc "Removes any notifications belonging to invalid resources"
       task :notifications, [] => :environment do
-        puts "=== Deleting Notification\n"
+        logger.info("=== Deleting Notification")
         invalid = 0
         Decidim::Notification.find_each do |notification|
           # Check if the resource class still exists
@@ -79,13 +79,13 @@ namespace :decidim do
           notification.destroy
           invalid += 1
         end
-        puts "===== Deleted #{invalid} invalid notifications\n"
+        logger.info("===== Deleted #{invalid} invalid notifications")
       end
 
       desc "Removes any resources from search index that do not exist"
       task :searchable_resources, [] => :environment do
-        puts "=== Deleting Searchable results\n"
-        puts "==== Deleting invalid spaces \n"
+        logger.info("=== Deleting Searchable results")
+        logger.info("==== Deleting invalid spaces ")
         invalid = 0
         Decidim::SearchableResource.where.not(decidim_participatory_space_type: nil).find_each do |search|
           search.decidim_participatory_space
@@ -93,9 +93,9 @@ namespace :decidim do
           search.destroy!
           invalid += 1
         end
-        puts "===== Deleted #{invalid} invalid spaces\n"
+        logger.info("===== Deleted #{invalid} invalid spaces")
 
-        puts "==== Deleting invalid resources from search index \n"
+        logger.info("==== Deleting invalid resources from search index ")
         invalid = 0
         Decidim::SearchableResource.find_each do |search|
           next unless search.resource.respond_to?(:component)
@@ -107,24 +107,31 @@ namespace :decidim do
           search.destroy!
           invalid += 1
         end
-        puts "===== Deleted #{invalid} invalid resources\n"
+        logger.info("===== Deleted #{invalid} invalid resources")
       end
 
-      desc "Removes orphan categorizations"
-      task fix_orphan_categorizations: :environment do
-        logger = Logger.new($stdout)
-        logger.info("Removing orphan categorizations...")
+      desc "Removes any categorizations belonging to invalid resources"
+      task categories: :environment do
+        logger.info("=== Removing orphan categorizations...")
+        invalid = 0
 
         Decidim::Categorization.find_each do |categorization|
-          categorization.destroy if categorization.categorizable.nil?
+          next unless categorization.categorizable.nil?
+
+          invalid += 1
+          categorization.destroy
+        rescue NameError
+          categorization.destroy!
+          invalid += 1
         end
+        logger.info("===== Deleted #{invalid} invalid resources")
       end
 
       desc "Update all blocked users notifications_sending_frequency setting"
       task fix_blocked_user_notification: :environment do
         logger.info("=== Updating all blocked users notifications_sending_frequency ...")
         blocked_users = 0
-        Decidim::User.blocked.where.not("notifications_sending_frequency = ?", "none").find_each do |blocked_user|
+        Decidim::User.blocked.where.not(notifications_sending_frequency: :none).find_each do |blocked_user|
           unless blocked_user.notifications_sending_frequency == "none"
             blocked_user.update(notifications_sending_frequency: "none")
             blocked_users += 1

data/lib/tasks/upgrade/decidim_active_storage_migration_tasks.rake

@@ -7,7 +7,7 @@ namespace :decidim do
       task :migrate_inline_images_to_active_storage, [:admin_email] => :environment do |_t, args|
         user = Decidim::User.find_by(email: args[:admin_email])
 
-        raise "Invalid admin. Please, provide the email of an admin with permissions to create editor images" unless user&.admin? && user&.admin_terms_accepted?
+        raise "Invalid admin. Please, provide the email of an admin with permissions to create editor images" unless user&.admin? && user.admin_terms_accepted?
 
         inline_images_available_attributes.each do |model, attributes|
           puts "=== Updating model #{model.name} (attributes: #{attributes.join(", ")})..."

data/lib/tasks/upgrade/migrations.rake

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+namespace :decidim do
+  namespace :upgrade do
+    desc "Replace legacy migration content"
+    task migrations: :environment do
+      available_modules = {
+        "accountability" => "Accountability",
+        "admin" => "Admin",
+        "ai" => "Ai",
+        "api" => "Api",
+        "assemblies" => "Assemblies",
+        "blogs" => "Blogs",
+        "budgets" => "Budgets",
+        "comments" => "Comments",
+        "conferences" => "Conferences",
+        "core" => "Core",
+        "debates" => "Debates",
+        "design" => "Design",
+        "dev" => "Dev",
+        "forms" => "Forms",
+        "initiatives" => "Initiatives",
+        "meetings" => "Meetings",
+        "pages" => "Pages",
+        "participatory_processes" => "ParticipatoryProcesses",
+        "proposals" => "Proposals",
+        "sortitions" => "Sortitions",
+        "surveys" => "Surveys",
+        "system" => "System",
+        "templates" => "Templates",
+        "verifications" => "Verifications"
+      }
+
+      available_modules.each do |key, value|
+        next unless Decidim.module_installed?(key.to_sym)
+
+        migration_files = Dir["Decidim::#{value}::Engine".constantize.root.join("db/migrate/*.rb")]
+        next if migration_files.blank?
+
+        migration_files.each do |file|
+          next if file.include?("active_storage")
+
+          replace_content(file)
+        end
+      end
+    end
+
+    private
+
+    def replace_content(file_path)
+      migration_file = File.basename(file_path)
+      version = migration_file.split("_").first
+      migration_file_base = migration_file.gsub!(/^\d+_/, "").gsub!(/\.rb$/, "")
+
+      target_file = Rails.root.glob("db/migrate/**_#{migration_file_base}.*.rb").first
+      return if target_file.blank?
+
+      scope = target_file.to_s.split(".")[-2]
+
+      source = File.binread(file_path)
+
+      # This has been extracted from activerecord file lib/active_record/migration.rb
+      inserted_comment = "# This migration comes from #{scope} (originally #{version})\n"
+      magic_comments = +""
+      loop do
+        source.sub!(/\A(?:#.*\b(?:en)?coding:\s*\S+|#\s*frozen_string_literal:\s*(?:true|false)).*\n/) do |magic_comment|
+          magic_comments << magic_comment
+          ""
+        end || break
+      end
+
+      if !magic_comments.empty? && source.start_with?("\n")
+        magic_comments << "\n"
+        source = source[1..-1]
+      end
+
+      new_source = "#{magic_comments}#{inserted_comment}#{source}"
+      old_source = File.binread(target_file)
+
+      return if old_source == new_source
+
+      logger.warn("[Patch migration] Replacing content of #{File.basename(target_file)}")
+
+      File.binwrite(target_file, new_source)
+    end
+
+    def logger
+      @logger ||= Logger.new($stdout)
+    end
+  end
+end