anchor_migrations 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 886e3d44b9b0a3bc3147c4f4eca63e86047a9cb83bd8f69d54a7912b8e922608
+  data.tar.gz: ceb5f6cb450ff6971f12dc3d663d4ab002b35d7564db793842b3198e86cead7b
+SHA512:
+  metadata.gz: 00b8f6345f4ffe5ebb17d2df959696a408e6044109f7f185e6e525b515e9390fa0ac25b8dbb4a7a7969eb5795e352904ba2f32299a5e4cfbc60708153485f235
+  data.tar.gz: e22efbb42d0c23d7cadeed1a06212c49fe6603564d249e05b3aa3e0cf83fb328f5a3a1812c3c517c86fb6c80470ff8b222de026f539d4d77b085f5c16aa6bed6

data/.rubocop.yml

@@ -0,0 +1,16 @@
+AllCops:
+  TargetRubyVersion: 3.3
+  Exclude:
+    - 'db/migrate/**/*'
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Metrics/MethodLength:
+    Max: 40
+
+Metrics/AbcSize:
+    Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+## [Unreleased]
+
+## [0.1.5] - 2025-07-11
+
+Anchors aweigh! This is a brand new gem with very limited usage. It's in an experimental status for the time being.
+
+- 0.1.x to version preceding the one above were yanked due to bugs
+- Initial release, tested end to end in a Rails app

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Andrew Atkinson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,175 @@
+# ⚓ Anchor Migrations
+Anchor Migrations are SQL DDL, non-blocking, idempotent, and augment the normal ORM migrations process.
+
+## Commands
+```sh
+anchor init         # initialize directories
+anchor generate     # generate an empty versioned .sql file, to be filled in
+anchor lint         # safety-lint all .sql files using Squawk
+anchor backfill     # Backfill a Rails migration from the SQL
+anchor migrate      # Run the Anchor Migration DDL
+```
+
+## Installation
+Add `anchor_migrations` to your `development` group Gemfile
+```rb
+group :development do
+  gem 'anchor_migrations'
+end
+```
+Then run `bundle install`.
+
+## Preconditions
+Anchor Migrations are restricted and opinionated for now, expecting a few things:
+- Postgres only, 13+
+- `DATABASE_URL` environment variable is set to the database to migrate (e.g. production), and is reachable, in order to apply migrations
+- `psql` client accessible in PATH
+- [Squawk](https://squawkhq.com) executable ([Quick Start documentation](https://squawkhq.com/docs/)) accessible in PATH
+
+## Safety linting and lock_timeout
+Squawk is used on SQL migrations to check for unsafe operations. For example, creating an index or dropping an index without using CONCURRENTLY is detected by Squak. Anchor Migrations will require safety-linted SQL, although right now it’s up to the developer to run `anchor lint` in their workflow.
+
+When Anchor Migration SQL is ready to apply, a psql client connection is used for that. By default a 2 second `lock_timeout`[^docs] is set.
+
+## What problems do Anchor migrations solve?
+1. Anchor Migrations are an additional mechanism to release safe DDL changes that don’t have code dependencies, while keeping all databases in sync using ORM migrations.
+
+Anchor Migrations are a process for organizations not using Trunk Based Development[^tbd] or frequent releases, to allow safe DDL to get released more frequently.
+
+Because Anchor Migrations generate the ORM (Active Record) migration *from* the SQL, Rails migrations stay in sync.
+
+## Example Anchor Migration SQL
+By default, Anchor Migrations are stored in `db/anchor_migrations` as `.sql` files:
+```sql
+-- anchor_migrations/20250623173850_create_index_tbl_col.sql
+CREATE INDEX CONCURRENTLY IF NOT EXISTS
+idx_trips_created_at ON trips (created_at);
+```
+
+Squawk runs on the SQL file above for "safety linting", looking for unsafe patterns.
+
+Run it using anchor migrations with the `lint` command:
+```sh
+~/app ➜ bundle exec anchor lint
+
+Found 0 issues in 1 file 🎉
+```
+
+## Example ORM (Active Record) Migration
+This Rails migration was generated from the Anchor Migration SQL file above.
+
+For this example, Strong Migrations is used, so the `safety_assured` block it expects is added to the Rails migration.
+```rb
+#
+# ################################################
+# DO NOT EDIT, generated by Anchor Migrations
+# Version: 20250623173850
+# File: anchor_migrations/20250623173850_anchor_migration.sql
+# ################################################
+#
+class CreateIndexIdxTripsCreatedAt < ActiveRecord::Migration[7.2]
+  disable_ddl_transaction!
+
+  def change
+    safety_assured do
+      execute <<-SQL
+        CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_trips_created_at ON trips (created_at);
+      SQL
+    end
+  end
+end
+```
+
+## Configuration
+Currently, limited configuration is supported.
+
+Anchor Migrations supports generating Strong Migrations-compatible Active Record migrations:
+```rb
+# config/initializers/anchor_migrations.rb
+AnchorMigrations.configure do |config|
+  config.use_strong_migrations = true
+end
+```
+
+## Example PR Workflow
+For a PR, add:
+1. The Anchor Migration SQL file.
+1. The normal Rails migration files: Run `db:migrate` like normal to apply the migration. The developer submits the migration file and the diff to `db/structure.sql` or `db/schema.rb` like they normally would.
+1. Get an "approval" describing your plans to run `bundle exec anchor migrate`. The approval can be a comment in the PR from a team member.
+1. With an approval, run `anchor migrate` and capture the output (see below). Once applied, move the SQL migration into `db/anchor_migrations/applied` and update your PR.
+1. Get PR approval and merge it in. The Rails migration "backfills" the DDL, applying it wherever it's needed.
+
+Example output of `bundle exec anchor migrate`:
+```
+Applying Version: 20250623173850
+CREATE INDEX CONCURRENTLY IF NOT EXISTS
+idx_trips_created_at ON trips (created_at);
+STDOUT:
+CREATE INDEX
+STDERR:
+Success!
+Applied Version: 20250623173850
+Exit code: 0
+```
+The idempotent Rails migration applies anywhere it's needed and the Rails app is deployed. Other developer databases, lower environments, CI, etc. When it reaches production, the Anchor Migration SQL DDL was already applied, so nothing happens. The Rails migration is idempotent.
+
+## Good uses of Anchor Migrations
+### Query support, data integrity, data quality
+Indexes (and eventually constraints) that support query performance or data integrity, but have no code dependencies, can be changed at a faster cadence, while keeping everything consistent.
+
+Indexes and constraints improve performance and data quality, and arguably shouldn’t be "blocked" by needing to wait for ORM migrations.
+
+### Long running DDL changes
+On large tables, creating indexes concurrently can take a long time. It's nice to perform that during a low activity period, requiring control over the timing, which isn't always possible with ORM migrations.
+
+## Anchor Migrations Properties
+### Idempotent
+Anchor Migrations in SQL must be written using idempotent tactics like `IF NOT EXISTS`.
+
+This allows the SQL to be the backfill source for an Active Record migration, which is then also idempotent.
+
+### Restricted DDL: What DDL is supported for Anchor Migrations?
+Only non-blocking, idempotent DDL is supported. This list is restricted heavily now although additional DDL types may be added in the future:
+1. `CREATE INDEX CONCURRENTLY IF NOT EXISTS`
+1. `DROP INDEX CONCURRENTLY IF EXISTS` (Postgres 13+)
+
+Roadmap operations, future gem releases:
+1. `ALTER TABLE ALTER COLUMN IF NOT EXISTS` (only `NULL` values)
+1. Add check constraint, initially not valid
+
+### Uses psql
+For now, Anchor Migrations assumes you're using psql to migrate, and that psql can connect to your target instance.
+
+### What’s out of scope for Anchor Migrations?
+Anchor Migrations are non-blocking and idempotent.
+
+For destructive operations like table drops, column drops, etc. with code dependencies, Anchor Migrations are not appropriate.
+
+That's because application code references need to be removed first.
+
+Use Strong Migrations or similar to help guide that process, and use regular Rails migrations.
+
+Some of those destructive operations are:
+1. `DROP TABLE`
+1. Adding non-nullable column, or a column with a default value
+1. Dropping constraints
+1. Adding initially valid constraints
+1. Add indexes without using concurrently
+
+[^docs]: <https://www.postgresql.org/docs/current/runtime-config-client.html>
+[^tbd]: <https://trunkbaseddevelopment.com>
+
+## Building and Testing
+```sh
+gem build anchor_migrations.gemspec
+gem install ./anchor_migrations-0.1.0.gem
+bundle exec rake test
+```
+
+## Testing Integration in Rails
+Add to the project's Gemfile, then run `bundle`.
+
+Once installed, test that it works by running:
+```sh
+bundle exec anchor help
+```

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+# TODO: GitHub Workflow is hanging, trying to disable the RuboCop portion
+# require "rubocop/rake_task"
+#
+# RuboCop::RakeTask.new
+
+# task default: %i[test rubocop]
+task default: %i[test]

data/exe/anchor

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "anchor_migrations"
+require "anchor_migrations/cli"
+
+AnchorMigrations::CLI.start(ARGV)

data/lib/anchor_migrations/cli.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "uri"
+require "open3"
+
+module AnchorMigrations
+  # Process command line arguments
+  class CLI
+    def self.start(args)
+      command = args.shift
+
+      case command
+      when "help"
+        new.help
+      when "init"
+        new.init
+      when "generate"
+        new.generate
+      when "lint"
+        new.lint
+      when "backfill"
+        new.generate_rails_migration
+      when "migrate"
+        new.migrate
+      else
+        new.help
+      end
+    end
+
+    def init
+      puts "Initializing anchor migrations structure..."
+
+      folders = [
+        AnchorMigrations::DEFAULT_DIR,
+        "#{AnchorMigrations::DEFAULT_DIR}/applied",
+        "config/initializers",
+        "db/migrate"
+      ]
+
+      folders.each do |folder|
+        if Dir.exist?(folder)
+          puts "Directory #{folder} already exists"
+        else
+          FileUtils.mkdir_p(folder)
+          puts "Created directory #{folder}"
+        end
+      end
+
+      puts "Checking for Squawk"
+      check_for_squawk
+
+      puts "Adding initializer"
+      InitializerGenerator.new.generate
+
+      puts "Anchor migrations structure initialized."
+    end
+
+    def generate
+      # TODO: accept file name argument
+      Generator.new.generate
+    end
+
+    def lint
+      unless Dir.exist?(AnchorMigrations::DEFAULT_DIR)
+        abort "Error: '#{AnchorMigrations::DEFAULT_DIR}' not found. Did you run anchor init?"
+      end
+      check_for_squawk
+      system("squawk lint #{AnchorMigrations::DEFAULT_DIR}/*.sql")
+    end
+
+    def migrate
+      # TODO: Only supporting one file for now. Expecting files to be moved into "applied" directory.
+      anchor_migration_file = Dir["#{AnchorMigrations::DEFAULT_DIR}/*.sql"].max
+      version = File.basename(anchor_migration_file).split("_").first
+      sql_ddl = File.read(anchor_migration_file)
+      cleaned_sql = AnchorMigrations::Utility.cleaned_sql(sql_ddl)
+      puts "Applying Version: #{version}"
+      puts cleaned_sql
+
+      if !ENV["DATABASE_URL"]
+        puts "DATABASE_URL must be set...exiting"
+        exit 1
+      else
+        base_url = URI.parse(ENV["DATABASE_URL"])
+        params = {
+          options: "-c lock_timeout=2s"
+        }
+        encoded = URI.encode_www_form(params)
+        encoded = encoded.gsub("+", "%20") # remove "+" for Postgres
+        conn_string = "#{base_url}?#{encoded}"
+        command = %(
+          psql #{conn_string} \
+            -c '#{cleaned_sql}'
+        )
+        stdout, stderr, status = Open3.capture3(command)
+        puts "STDOUT:\n#{stdout}"
+        puts "STDERR:\n#{stderr}"
+        if status.success?
+          puts "Success!"
+          puts "Applied Version: #{version}"
+        end
+        puts "Exit code: #{status.exitstatus}"
+      end
+    end
+
+    def generate_rails_migration
+      RailsMigrationGenerator.new.generate
+    end
+
+    def help
+      puts "Available commands: init, generate, lint, backfill, migrate"
+    end
+
+    private
+
+    def check_for_squawk
+      if !system("which squawk > /dev/null 2>&1")
+        abort <<~MSG
+          "Error: 'squawk' command not found in PATH."
+          Is it installed? https://squawkhq.com/docs/
+        MSG
+      else
+        puts "Squawk found."
+      end
+    end
+  end
+end

data/lib/anchor_migrations/configuration.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module AnchorMigrations
+  # Configuration for gem
+  class Configuration
+    attr_accessor :use_strong_migrations
+
+    def initialize
+      @use_strong_migrations = false
+    end
+  end
+end

data/lib/anchor_migrations/generator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module AnchorMigrations
+  # Generate Anchor Migrations SQL files
+  class Generator
+    def anchor_migrations_dir
+      File.join(AnchorMigrations::DEFAULT_DIR)
+    end
+
+    def generate
+      output_file = "#{anchor_migrations_dir}/#{rails_style_timestamp}_anchor_migration.sql"
+      File.write(output_file, sql_migration_template)
+      puts "Wrote file: #{output_file}"
+      puts File.read(output_file)
+    end
+
+    def rails_style_timestamp
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    end
+
+    def sql_migration_template
+      <<~SQL_TEMPLATE.strip
+        -- Generated by anchor_migrations #{VERSION}
+        --
+        -- Examples:
+        -- CREATE INDEX CONCURRENTLY IF NOT EXISTS
+        -- idx_tbl_col ON tbl (col);
+        --
+        -- DROP INDEX CONCURRENTLY IF EXISTS
+        -- idx_tbl_col;
+      SQL_TEMPLATE
+    end
+  end
+end

data/lib/anchor_migrations/initializer_generator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module AnchorMigrations
+  # Create a Rails migration from Anchor Migration SQL
+  class InitializerGenerator
+    def generate
+      filename = "anchor_migrations.rb"
+      file = "config/initializers/#{filename}"
+      return if File.exist?(file)
+
+      File.write(file, initalizer_template)
+      puts "Wrote file: #{file}"
+      puts File.read(file)
+    end
+
+    def initalizer_template
+      <<~TEMPLATE.strip
+        AnchorMigrations.configure do |config|
+          config.use_strong_migrations = false
+        end
+      TEMPLATE
+    end
+  end
+end

data/lib/anchor_migrations/rails_loader.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AnchorMigrations
+  # Load the Rails environment
+  module RailsLoader
+    def self.load_rails!
+      env_path = File.expand_path("config/environment", Dir.pwd)
+      require "#{env_path}.rb" if File.exist?("#{env_path}.rb")
+    end
+  end
+end

data/lib/anchor_migrations/rails_migration_generator.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module AnchorMigrations
+  #
+  # Create a Rails migration from Anchor Migration SQL
+  # Expects Anchor Migrations to be in db/anchor_migrations
+  # Expects to generate Rails Migrations into db/migrate
+  # Expects to parse a Rails-style timestamp from beginning of Anchor Migrations file
+  #
+  class RailsMigrationGenerator
+    def initialize(anchor_migrations_dir: AnchorMigrations::DEFAULT_DIR)
+      if @anchor_migration_file = Dir["#{anchor_migrations_dir}/*.sql"].max
+        @migration_version = File.basename(@anchor_migration_file).split("_").first
+        sql_file_content = File.read(@anchor_migration_file)
+        @cleaned_sql_ddl = AnchorMigrations::Utility.cleaned_sql(sql_file_content)
+        build_file_name_and_class_name
+        AnchorMigrations::RailsLoader.load_rails!
+      else
+        abort "Can't find dir #{anchor_migrations_dir} or file #{Dir["#{anchor_migrations_dir}/*.sql"]}"
+      end
+    end
+
+    def generate(write_file: true)
+      output_file = "#{AnchorMigrations::RAILS_MIG_DIR}/#{@migration_version}_#{@migration_file_name_no_version}"
+      migration_content = rails_generate_migration_code
+      if write_file
+        File.write(output_file, migration_content)
+        puts "Wrote file: #{output_file}"
+        puts File.read(output_file)
+      end
+      migration_content # for tests
+    end
+
+    private
+
+    def rails_version_major_minor
+      if defined?(Rails) && defined?(Rails::VERSION)
+        major = Rails::VERSION::MAJOR
+        minor = Rails::VERSION::MINOR
+        "#{major}.#{minor}"
+      else
+        "X.Y" # can't load Rails, this is only for testing outside Rails
+      end
+    end
+
+    def build_file_name_and_class_name
+      # Strip out the Rails-style version number
+      @migration_version = File.basename(@anchor_migration_file).split("_").first
+
+      # Break up by underscore, and join together with underscore, for only the basename
+      path = File.basename(@anchor_migration_file)
+                 .split("_")[1..-1].join("_")
+
+      # Strip out the extension (.sql)
+      filename_base = File.basename(path, File.extname(path))
+
+      # Create a capitalized words version for the migration class name
+      @migration_class_name = filename_base.split("_")
+                                           .map(&:capitalize).join
+
+      # Create a filename with .rb extension
+      @migration_file_name_no_version = "#{filename_base}.rb"
+    end
+
+    def migration_change_method_body
+      if AnchorMigrations.configuration.use_strong_migrations
+        <<-TEMPL
+        safety_assured do
+          execute <<-SQL
+            #{@cleaned_sql_ddl}
+          SQL
+        end
+        TEMPL
+      else
+        <<-TEMPL
+        execute <<-SQL
+          #{@cleaned_sql_ddl}
+        SQL
+        TEMPL
+      end
+    end
+
+    # Assume it's a concurrently operation for now, disable_ddl_transaction!
+    def rails_generate_migration_code
+      <<~MIG_TEMPLATE.strip
+        #
+        # ################################################
+        # DO NOT EDIT, generated by Anchor Migrations
+        # Version: #{@migration_version}
+        # Source File: #{@anchor_migration_file}
+        # Target File: #{AnchorMigrations::RAILS_MIG_DIR}/#{@migration_version}_#{@migration_file_name_no_version}
+        # ################################################
+        #
+        class #{@migration_class_name} < ActiveRecord::Migration[#{rails_version_major_minor}]
+          disable_ddl_transaction!
+
+          def change
+            #{migration_change_method_body}
+          end
+        end
+      MIG_TEMPLATE
+    end
+  end
+end

data/lib/anchor_migrations/railtie.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rails/railtie" if defined?(Rails)
+
+module AnchorMigrations
+  # Rails integration
+  class Railtie < Rails::Railtie
+    initializer "anchor_migrations.configure" do
+      AnchorMigrations.configure do |config|
+        config.use_strong_migrations ||= false
+      end
+    end
+  end
+end

data/lib/anchor_migrations/utility.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module AnchorMigrations
+  # Utility functions
+  module Utility
+    # Strip out SQL comments that start with
+    # double hyphen "--"
+    def self.cleaned_sql(input_sql)
+      clean_lines = []
+      input_sql.lines.each do |line|
+        clean_lines << line unless line =~ /^\s*--/
+      end
+      clean_lines.join
+    end
+  end
+end

data/lib/anchor_migrations/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module AnchorMigrations
+  VERSION = "0.1.5"
+  DEFAULT_DIR = "db/anchor_migrations"
+  RAILS_MIG_DIR = "db/migrate"
+end

data/lib/anchor_migrations.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "anchor_migrations/configuration"
+require_relative "anchor_migrations/rails_loader"
+require_relative "anchor_migrations/utility"
+require_relative "anchor_migrations/version"
+require_relative "anchor_migrations/generator"
+require_relative "anchor_migrations/rails_migration_generator"
+require_relative "anchor_migrations/initializer_generator"
+require_relative "anchor_migrations/cli"
+require_relative "anchor_migrations/railtie" if defined?(Rails)
+
+module AnchorMigrations
+  class Error < StandardError; end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset
+      @configuration = Configuration.new
+    end
+  end
+end

data/sig/anchor_migrations.rbs

@@ -0,0 +1,4 @@
+module AnchorMigrations
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: anchor_migrations
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+platform: ruby
+authors:
+- Andrew Atkinson
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-07-12 00:00:00.000000000 Z
+dependencies: []
+description: Description
+email:
+- andyatkinson@gmail.com
+executables:
+- anchor
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/anchor
+- lib/anchor_migrations.rb
+- lib/anchor_migrations/cli.rb
+- lib/anchor_migrations/configuration.rb
+- lib/anchor_migrations/generator.rb
+- lib/anchor_migrations/initializer_generator.rb
+- lib/anchor_migrations/rails_loader.rb
+- lib/anchor_migrations/rails_migration_generator.rb
+- lib/anchor_migrations/railtie.rb
+- lib/anchor_migrations/utility.rb
+- lib/anchor_migrations/version.rb
+- sig/anchor_migrations.rbs
+homepage: https://github.com/andyatkinson/anchor_migrations
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/andyatkinson/anchor_migrations
+  source_code_uri: https://github.com/andyatkinson/anchor_migrations
+  changelog_uri: https://github.com/andyatkinson/anchor_migrations/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.8
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Anchor migrations
+test_files: []