fixture_champagne 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9c999bd5772d62cce811ec251c0a6703a58bd7daf7b31d6d00ed08fe80f9133f
+  data.tar.gz: 1bb147d5724d90fd9341b480b449218e71827ab00e694bc6c10d1ffaa99bda59
+SHA512:
+  metadata.gz: b0a14630348c2e463ca683801cc72be51e9e8b65466a1fb73143072a486979991484dc6d2c80fe081287821d4afa8570c45ec4f33c13f4d2996a22c2202021f4
+  data.tar.gz: 6c6e4d55bf6654cee801ca4545f052351f4ef81505921240e1e007d362e12e9c050f22cc3f9305c566b8946b7fd81831309dce87f00619266c35bd2263cf3bd5

data/README.md

@@ -0,0 +1,267 @@
+# Fixture Champagne :champagne:
+
+### Fixture migrations for your Ruby on Rails applications
+
+
+Fixture Champagne is designed to help you keep your fixtures tidy, applying the data migration pattern to create, update or destroy fixtures.
+
+It supports label references for `belongs_to` associations, both regular and polymorphic, single table inheritance, enums and all the different data types.
+
+
+## Installation
+
+1. Add `fixture-champagne` to the development group of your Rails app's `Gemfile`:
+
+```ruby
+group :development do
+  gem 'fixture-champagne'
+end
+```
+
+2. Then, in your project directory:
+
+```sh
+# Download and install
+$ bundle install
+
+# Generate fixture_migrations folder in your test or spec folder, depending on your test suite
+$ bin/rails generate fixture_champagne:install
+```
+
+
+## Usage
+
+
+### Sync fixtures with schema
+
+If your schema version changed and you need to add any new column to the current fixtures, simply run:
+
+```sh
+bin/rails fixture_champagne:migrate
+```
+
+The migration process will regenarate your `fixtures` folder.
+
+
+### Add, update or destroy fixtures
+
+If you need specific values for the any new columns or you want to populate a newly created table, you might find it useful to create a fixture migration. This can be done using the generator:
+
+```sh
+bin/rails generate fixture_champagne:migration new_migration_name
+```
+
+A new versioned migration file will be created in the `fixture_migrations` folder. If this is your first migration, make sure that folder exists or run the installation command.
+
+`ActiveRecord` queries and fixture accessors can be used inside the migrations. For example, let's suppose you've just added the `Enemy` model and you need to create a new enemy fixture having the following files:
+
+```ruby
+# models/level.rb
+
+class Level < ApplicationRecord
+  has_many :enemies
+end
+
+# models/enemy.rb
+
+class Enemy < ApplicationRecord
+  belongs_to :level
+end
+```
+
+```yaml
+# test/fixtures/levels.yml
+
+first_level:
+  name: Initial
+```
+
+You can then generate a new migration:
+
+```sh
+bin/rails generate fixture_champagne:migration create_initial_enemy
+```
+
+The generator automatically adds a version number to the new migration file, which is important to keep track of executed migrations. Also, the migration filename must correspond with the migration class inside the file. All this should feel similar to the way schema migrations are handled by Rails.
+
+Add the `up` and `down` logic to the new migration:
+
+```ruby
+# 20230126153650_create_initial_enemy.rb
+
+class CreateInitialEnemy < FixtureChampagne::Migration::Base
+  def up
+    unless Enemy.find_by(name: "Initial Enemy").present?
+      Enemy.create!(name: "Initial Enemy", level: levels(:first_level)) 
+    end
+  end
+
+  def down
+    Enemy.find_by(name: "Initial Enemy").destroy!
+  end
+end
+```
+
+Running `bin/rails fixture_champagne:migrate` will execute the `up` method of all pending migrations in ascending version order to update the test database. The `fixtures` folder is regenerated at the end of the process only if all the migrations were successfully executed. In this case, it would generate the following file:
+
+```yaml
+# test/fixtures/enemies.yml
+
+enemies_12345678:
+  level: first_level
+  name: Initial Enemy
+```
+
+If the migration is successful, the migrator will take the max version all available migrations and the current schema version and save both numbers in `test/.fixture_champagne_versions.yml` (or `spec/` if using Rspec) to identify future pending migrations.
+
+The default label for a new fixture is a unique identifier composed of the table name and the record id. However, this label can be configured (keep reading to know how).
+
+
+### Rollback
+
+You can optionally complete the `down` method in the migration to allow rollback. Running the following command will rollback the last executed migration:
+
+```sh
+bin/rails fixture_champagne:rollback
+```
+
+New max version will be set to the next one in descending order. Schema version won't change. Any changes in the configuration apply to both `migrate` or `rollback`.
+
+
+### Configuration
+
+You can better control fixture migrations by creating a config YAML file: `test/fixture_champagne.yml` (or, again, `spec/`).
+
+#### Overwrite current fixtures
+
+Setting the `overwrite` key to `false` will leave your current fixtures untouched. The generated fixtures will go to `tmp/fixtures`. Default value is set to `true`.
+
+```yaml
+# test/fixture_champagne.yml
+
+overwrite: false
+```
+
+#### Fixture labels
+
+Setting the `label` key will allow you to control the names your fixtures get. It accepts a hash, where keys are table names and values are label templates: strings interpolated with a I18n style syntax. Interpolated keywords must be instance methods or attributes.
+
+In the previous example, you can configure:
+
+```yaml
+# test/fixture_champagne.yml
+
+label:
+  enemy: "%{name}"    
+```
+
+To generate:
+
+```yaml
+# test/fixtures/enemies.yml
+
+initial_enemy:
+  level: first_level
+  name: Initial Enemy
+```
+
+#### Rename current fixtures
+
+Setting the `rename` key to `true` will force every fixture label to follow the templates in the configuration. Default value is `false`. If any table is not configured, the default label will be used (something like `%{table_name}_%{id}` if `table_name` was an instance method).
+
+```yaml
+# test/fixture_champagne.yml
+
+rename: true
+```
+
+If `rename` is set to `true`, every time you run `migrate` or `rollback` all fixtures will be regenerated in the corresponding folder (depending on `overwrite`), even if there's no pending migrations or schema version is up to date. Keep in mind that a renaming might break the fixture accessors in your tests or previous migrations. It could also break unsupported attachment fixtures.
+
+#### Ignore tables
+
+Setting the `ignore` key will allow you to control which tables get saved as fixtures. It accepts an array, where items are table names. Any table ignored by this configuration will disappear from the corresponding fixture folder (depending on `overwrite`).
+
+Let's say for example that each time a new `Enemy` gets created, it creates an associated `Event` in a callback that runs some processing in the background. If that event belongs to a polymorphic `eventable`, for every single one of those, a new event will be added to your fixtures, making the `events.yml` a big but not very useful file. Or maybe events get incinerated a couple of days after execution and it makes no sense to have fixtures for them. In any of those situations, you could ignore them from fixtures like this:  
+
+```yaml
+# test/fixture_champagne.yml
+
+ignore:
+  - events
+```
+
+This configuration does not change the shape of the database after the migrations as the database transactions are left untouched (for example, events will be created anyway) but next time fixtures get loaded, no item from ignored tables will be present. This could break the integrity of your database, so make sure everything is working afterwards.
+
+
+### Manually adding or editing fixtures
+
+Nothing prevents you from manually editing your fixture files. Take into account that the next time that you run migrations, what's on your fixtures will define the initial state of your migration database, which could break previous migrations or rollbacks (in the rare case that you need to run them again). The next time you run `migrate`, the migrator will tidy the information you added manually.
+
+
+### Generated fixtures folder structure
+
+On namespaced models, the migrator will create a folder for each level and a `.yml` file for the last one. For example, `Level::Enemy` fixtures will be saved in `fixtures/level/enemies.yml`.
+
+If you use single table inheritance, then the file will correspond with the parent model, the owner of the table. For example, `class Weapon::Rocket < Weapon; end` will be saved in `fixtures/weapons.yml`.
+
+All fixtures files that correspond to attachments will be copied as they are. Those are the ones located in `fixtures/files`, `fixtures/active_storage` and `fixtures/action_text`.
+
+
+## Features currently not supported
+
+The following fixture features are not supported:
+- More than one test suite in the same application
+- Dynamic ERB fixtures (considered a code smell in the [Rails documentation](https://edgeapi.rubyonrails.org/classes/ActiveRecord/FixtureSet.html))
+- Explicit `created_at` or `updated_at` timestamps (favoured autofilled ones)
+- Explicit `id` (favoured label references)
+- Fixture label interpolation (favoured configuration)
+- HABTM (`have_and_belong_to_many`) associations as inline lists
+- Support for YAML defaults (this could be nice)
+
+As stated before, at least for now, fixtures files that correspond to attachments will be copied as they are. This means:
+- This fixtures must be generated manually
+- This fixtures must be updated manually if other fixtures labels change
+- All this files will be left untouched
+
+##  A few soft recommendations
+
+
+#### Don't have too many fixtures
+
+The goal of this gem is to make it easier to keep fixtures tidy and up to date as things start to get complicated, so that factories aren't your only option. But no gem can replace good ol' discipline. If a new fixture gets added for every single small feature or bugfix, maintenance will be hard no matter the tool.
+
+Reduce repetition, reuse fixtures using helpers to modify them in the tests or use factories for some of your tests.
+
+#### Make your migrations idempotent
+
+Versions saved in `.fixture_champagne_versions.yml` are there to ensure that your migrations are only executed once, but it would be a good idea to design your migrations to be idempotent, meaning that executing them more than once does not change the results.
+
+#### Raise errors
+
+Raise errors to stop the migration if there are invalid objects. A good way to do that is using `ActiveRecord` bang methods `create!`, `update!` and `destroy!`.
+
+#### Review changes before git commits
+
+The safest way to rollback a migration is to revert any changes made to your `fixtures` folder and versions file using git. After migrating, inspect the changes made to the fixture folder and run the whole test suite.
+
+
+## Contributing
+
+Feel free to open an issue if you have any doubt, suggestion or find buggy behaviour. If it's a bug, it's always great if you can provide a minimum Rails app that reproduces the issue.
+
+This project uses [Rubocop](https://github.com/rubocop/rubocop) to format Ruby code. Please make sure to run `rubocop` on your branch before submitting pull requests. You can do that by running `bundle exec rubocop -A`.
+
+Also run the tests for each supported Rails version with:
+```sh
+bundle exec appraisal rake test
+```
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+
+## Code of Conduct
+
+Everyone interacting in the FixtureChampagne project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/fixture_champagne/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+
+require "bundler/gem_tasks"
+
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "Fixture Champagne"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.md")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+$LOAD_PATH << File.expand_path("test", __dir__)
+require "rails/plugin/test"
+
+task default: :test

data/lib/fixture_champagne/migration.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module FixtureChampagne
+  # Migration contain naming rules for migrations files and objects
+  class Migration
+    MIGRATION_FILENAME_REGEXP = /\A([0-9]+)_([_a-z0-9]*)\.rb\z/.freeze
+
+    class << self
+      def new_migration_version
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+    end
+
+    # Migration::Base is the ancestor of generated fixture migrations.
+    #
+    # Inheriting from Base allows migrations to have access to fixture accessors.
+    class Base
+      attr_reader :version, :migrator
+
+      def initialize(version)
+        @version = version
+      end
+
+      def migrate(direction:, migrator:)
+        @migrator = migrator
+        send(direction)
+      end
+
+      private
+
+      def method_missing(name, *args, **kwargs, &block)
+        if migrator.pre_existing_fixture_accessors.include?(name.to_s)
+          migrator.send(name, *args, **kwargs, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        if include_private && migrator.pre_existing_fixture_accessors.include?(name.to_s)
+          true
+        else
+          super
+        end
+      end
+    end
+
+    Proxy = Struct.new(:name, :version, :filename) do
+      def initialize(name, version, filename)
+        super
+        @migration = nil
+      end
+
+      def basename
+        File.basename(filename)
+      end
+
+      delegate :migrate, to: :migration
+
+      private
+
+      def migration
+        @migration ||= load_migration
+      end
+
+      def load_migration
+        begin
+          Object.send(:remove_const, name)
+        rescue StandardError
+          nil
+        end
+
+        load(File.expand_path(filename))
+        name.constantize.new(version)
+      end
+    end
+  end
+end

data/lib/fixture_champagne/migration_context.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module FixtureChampagne
+  # MigrationContext sets the context in which a fixture migration is run.
+  #
+  # A migration context checks where the application files are located, which could be
+  # in /test if the app uses Minitest or /spec if the app uses Rspec, and from that base
+  # it decides where everything else is located:
+  # - Fixture migrations folder
+  # - Configuration YAML file
+  # - Saved versions YAML file
+  # - Fixtures path
+  #
+  # With all that it decides which migrations are pending, which are executed and the target
+  # versions. Depending on the method called, it also decides the direction the Migrator should execute.
+  class MigrationContext
+    class << self
+      def migrate
+        build_context.migrate
+      end
+
+      def rollback
+        build_context.rollback
+      end
+
+      def build_context
+        new(
+          fixture_migrations_path: fixture_migrations_path,
+          schema_current_version: schema_current_version,
+          fixtures_migration_version: fixture_versions["version"]&.to_i || 0,
+          fixtures_schema_version: fixture_versions["schema_version"]&.to_i || 0,
+          configuration: configuration
+        )
+      end
+
+      def fixture_migrations_path
+        raise MissingMigrationsFolderError unless expected_fixture_migrations_path.exist?
+
+        expected_fixture_migrations_path
+      end
+
+      def expected_fixture_migrations_path
+        test_suite_folder_path.join("fixture_migrations")
+      end
+
+      def test_suite_folder_path
+        rspec_path = Rails.root.join("test")
+        minitest_path = Rails.root.join("spec")
+
+        if minitest_path.exist?
+          minitest_path
+        elsif rspec_path.exist?
+          rspec_path
+        else
+          raise "No test nor spec folder found"
+        end
+      end
+
+      def schema_current_version
+        ::ActiveRecord::Migrator.current_version
+      end
+
+      def fixture_versions
+        @fixture_versions ||= if fixture_versions_path.exist?
+                                YAML.load_file(fixture_versions_path)
+                              else
+                                {}
+                              end
+      end
+
+      def fixture_versions_path
+        test_suite_folder_path.join(".fixture_champagne_versions.yml")
+      end
+
+      def configuration
+        @configuration ||= if configuration_path.exist?
+                             Configuration.new(YAML.load_file(configuration_path))
+                           else
+                             Configuration.new({})
+                           end
+      end
+
+      def configuration_path
+        test_suite_folder_path.join("fixture_champagne.yml")
+      end
+
+      def fixtures_path
+        test_suite_folder_path.join("fixtures")
+      end
+    end
+
+    attr_reader :fixture_migrations_path, :schema_current_version,
+                :fixtures_migration_version, :fixtures_schema_version, :configuration
+
+    def initialize(
+      fixture_migrations_path:, schema_current_version:,
+      fixtures_migration_version:, fixtures_schema_version:,
+      configuration:
+    )
+      @fixture_migrations_path = fixture_migrations_path
+      @schema_current_version = schema_current_version
+      @fixtures_migration_version = fixtures_migration_version
+      @fixtures_schema_version = fixtures_schema_version
+      @configuration = configuration
+    end
+
+    def migrate
+      # If rename_fixtures? is set to true, the migration should run as some label could have changed.
+      if pending_migrations.any? || fixtures_schema_version != schema_current_version || configuration.rename_fixtures?
+        up
+      else
+        puts "No fixture migrations pending."
+      end
+    end
+
+    def rollback
+      if executed_migrations.any?
+        down
+      else
+        puts "No migration to rollback."
+      end
+    end
+
+    def up
+      Migrator.new(
+        direction: :up,
+        migrations: pending_migrations,
+        target_migration_version: up_target_fixture_migration_version,
+        target_schema_version: schema_current_version,
+        configuration: configuration
+      ).migrate
+    end
+
+    def down
+      Migrator.new(
+        direction: :down,
+        migrations: [executed_migrations.last],
+        target_migration_version: down_target_fixture_migration_version,
+        target_schema_version: schema_current_version,
+        configuration: configuration
+      ).migrate
+    end
+
+    def up_target_fixture_migration_version
+      return fixtures_migration_version if pending_migrations.empty?
+
+      pending_migrations.map(&:version).max
+    end
+
+    def down_target_fixture_migration_version
+      return 0 if executed_migrations.one?
+
+      executed_migrations.last(2).first.version
+    end
+
+    def pending_migrations
+      migrations.select { |m| m.version > fixtures_migration_version }
+    end
+
+    def executed_migrations
+      migrations.select { |m| m.version <= fixtures_migration_version }
+    end
+
+    def migrations
+      @migrations ||= set_migrations
+    end
+
+    def set_migrations
+      migrations = migration_files.map do |file|
+        version, name = parse_migration_filename(file)
+        raise IllegalMigrationNameError, file unless version
+
+        Migration::Proxy.new(name.camelize, version.to_i, file)
+      end
+
+      migrations.sort_by(&:version)
+    end
+
+    def migration_files
+      Dir["#{fixture_migrations_path}/**/[0-9]*_*.rb"]
+    end
+
+    def parse_migration_filename(filename)
+      File.basename(filename).scan(Migration::MIGRATION_FILENAME_REGEXP).first
+    end
+
+    Configuration = Struct.new(:configuration_data) do
+      def initialize(configuration_data)
+        super
+        @configuration_data = configuration_data.with_indifferent_access
+      end
+
+      def label_templates
+        @configuration_data["label"] || {}
+      end
+
+      def overwrite_fixtures?
+        return true unless @configuration_data.key?("overwrite")
+
+        @configuration_data["overwrite"]
+      end
+
+      def rename_fixtures?
+        @configuration_data["rename"]
+      end
+
+      def ignored_tables
+        @configuration_data["ignore"].to_a || []
+      end
+    end
+  end
+end

data/lib/fixture_champagne/migrator.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+require_relative "test_fixtures"
+
+module FixtureChampagne
+  # Migrator parses pre existing fixtures, executes given migrations in the given direction and regenerates fixtures.
+  #
+  # The migrator implements the TestFixtures module to have access to a test database with pre existing fixtures
+  # already loaded and fixture accessors. It allows migrations access to all this.
+  # It contains the rules on how to avoid repeated fixtures, how to handle attached files, where to put temporary
+  # fixtures before overwritting (if necessary) and how to structure the fixtures folder tree.
+  class Migrator
+    include TestFixtures
+
+    attr_reader :direction, :migrations, :target_migration_version, :target_schema_version, :configuration
+
+    class << self
+      def fixture_unique_id(table_name:, id:)
+        "#{table_name}_#{id}"
+      end
+
+      def tmp_fixture_path
+        Rails.root.join("tmp", "fixtures")
+      end
+
+      def fixture_attachment_folders
+        %w[files active_storage action_text].map { |f| fixture_path.join(f) }
+      end
+    end
+
+    def initialize(
+      direction:, migrations:,
+      target_migration_version:, target_schema_version:, configuration:
+    )
+      @direction = direction
+      @migrations = migrations
+      @target_migration_version = target_migration_version
+      @target_schema_version = target_schema_version
+      @configuration = configuration
+    end
+
+    def migrate
+      before_migrate
+
+      process_pre_existing_fixtures
+      run_migrations
+      create_fixture_files_from_test_db
+
+      after_migrate
+    end
+
+    def process_pre_existing_fixtures
+      @pre_existing_fixtures_label_mapping = pre_existing_fixture_sets.each_with_object({}) do |fixture_set, mapping|
+        fixture_set.fixtures.each do |label, fixture|
+          unique_id = fixture_unique_id(fixture, fixture_set)
+          if mapping.key?(unique_id)
+            raise RepeatedFixtureError,
+                  "repeated fixture in preprocess for label #{label}, unique id #{unique_id}"
+          end
+          mapping[unique_id] = label.to_s
+        end
+      end
+    end
+
+    def run_migrations
+      migrations.each { |m| m.migrate(direction: direction, migrator: self) }
+    end
+
+    def create_fixture_files_from_test_db
+      klasses = fixtureable_models
+      fixtures_data = build_fixture_data(klasses)
+      create_new_fixture_files(klasses, fixtures_data)
+    end
+
+    # Only generate fixture files for application models that own a table to avoid several files
+    # in the case of STI.
+    def fixtureable_models
+      descendants = ApplicationRecord.descendants
+      descendants.filter(&:table_exists?).map do |descendant|
+        next if configuration.ignored_tables.include?(descendant.table_name.to_s)
+
+        table_ancestor = descendant
+        table_ancestor = table_ancestor.superclass while table_ancestor.superclass.table_exists?
+        table_ancestor
+      end.compact.uniq
+    end
+
+    def build_fixture_data(klasses)
+      data = serialize_database_records(klasses)
+
+      data.each_with_object({}) do |(table, table_data), sorted_data|
+        next if table_data.empty?
+
+        sorted_data[table] = table_data.sort.to_h
+      end
+    end
+
+    def serialize_database_records(klasses)
+      klasses.each_with_object({}) do |klass, hash|
+        table_name = klass.table_name.to_s
+        if hash.key?(table_name)
+          raise RepeatedFixtureError,
+                "repeated table key for new fixtures, table #{table_name}, class: #{klass}"
+        end
+
+        hash[table_name] = serialize_table_records(klass)
+      end
+    end
+
+    def serialize_table_records(klass)
+      table_data = {}
+
+      klass.all.each do |record|
+        label = fixture_label(record)
+        if table_data.key?(label)
+          raise RepeatedFixtureError,
+                "repeated fixture in serialization for label #{label}, class #{klass}"
+        end
+
+        table_data[label] = fixture_serialized_attributes(record)
+      end
+
+      table_data
+    end
+
+    # Record id is built from fixture label via ActiveRecord::FixtureSet.identify
+    def fixture_unique_id(fixture, fixture_set)
+      self.class.fixture_unique_id(table_name: fixture_set.table_name, id: fixture.find.id)
+    end
+
+    def fixture_label(record)
+      labeler.label_for(record: record)
+    end
+
+    def labeler
+      @labeler ||= Labeler.new(
+        pre_existing_fixtures_labels: @pre_existing_fixtures_label_mapping,
+        templates: configuration.label_templates,
+        rename: configuration.rename_fixtures?
+      )
+    end
+
+    def fixture_serialized_attributes(record)
+      serializer.serialized_attributes_for(record: record)
+    end
+
+    def serializer
+      @serializer ||= Serializer.new(labeler: labeler)
+    end
+
+    def create_new_fixture_files(klasses, fixtures_data)
+      setup_temporary_fixtures_dir
+      copy_fixture_attachments
+      klasses.each do |klass|
+        data = fixtures_data[klass.table_name]
+        filename = temporary_fixture_filename(klass)
+        create_temporary_fixture_file(data, filename)
+      end
+      return unless configuration.overwrite_fixtures?
+
+      overwrite_fixtures
+      remember_new_fixture_versions
+    end
+
+    def setup_temporary_fixtures_dir
+      FileUtils.rm_r(self.class.tmp_fixture_path, secure: true) if self.class.tmp_fixture_path.exist?
+      FileUtils.mkdir(self.class.tmp_fixture_path)
+    end
+
+    def copy_fixture_attachments
+      self.class.fixture_attachment_folders.each do |folder|
+        FileUtils.cp_r(folder, self.class.tmp_fixture_path) if folder.exist?
+      end
+    end
+
+    def temporary_fixture_filename(klass)
+      parts = klass.to_s.split("::").map(&:underscore)
+      parts << parts.pop.pluralize.concat(".yml")
+      self.class.tmp_fixture_path.join(*parts)
+    end
+
+    def create_temporary_fixture_file(data, filename)
+      FileUtils.mkdir_p(filename.dirname)
+      File.open(filename, "w") do |file|
+        yaml = YAML.dump(data).gsub(/\n(?=[^\s])/, "\n\n").delete_prefix("---\n\n")
+        file.write(yaml)
+      end
+    end
+
+    def overwrite_fixtures
+      removable_fixture_path = self.class.fixture_path.dirname.join("old_fixtures")
+      FileUtils.mv(self.class.fixture_path, removable_fixture_path)
+      FileUtils.mv(self.class.tmp_fixture_path, self.class.fixture_path)
+      FileUtils.rm_r(removable_fixture_path, secure: true)
+    end
+
+    def remember_new_fixture_versions
+      File.open(MigrationContext.fixture_versions_path, "w") do |file|
+        yaml = YAML.dump({ "version" => target_migration_version, "schema_version" => target_schema_version })
+        file.write(yaml)
+      end
+    end
+
+    # Labeler decides how a fixture should be labeled based on the config file and interpolation rules.
+    class Labeler
+      INTERPOLATION_PATTERN = /%\{([\w|]+)\}/.freeze
+
+      def initialize(pre_existing_fixtures_labels:, templates:, rename:)
+        @pre_existing_fixtures_labels = pre_existing_fixtures_labels
+        @templates = templates
+        @rename = rename
+      end
+
+      def label_for(record:)
+        if @rename
+          build_label_for(record)
+        else
+          find_label_for(record) || build_label_for(record)
+        end
+      end
+
+      private
+
+      def find_label_for(record)
+        @pre_existing_fixtures_labels[record_unique_id(record)]
+      end
+
+      def build_label_for(record)
+        template = @templates[record.class.table_name]
+
+        if template.nil? || template == "DEFAULT"
+          default_label(record)
+        else
+          interpolate_template(template, record)
+        end
+      end
+
+      def default_label(record)
+        record_unique_id(record)
+      end
+
+      def record_unique_id(record)
+        Migrator.fixture_unique_id(table_name: record.class.table_name, id: record.id)
+      end
+
+      def interpolate_template(template, record)
+        template.gsub(INTERPOLATION_PATTERN) do
+          attribute = ::Regexp.last_match(1).to_sym
+          value = if record.respond_to?(attribute)
+                    record.send(attribute)
+                  else
+                    raise WrongFixtureLabelInterpolationError, attribute: attribute, klass: record.class
+                  end
+          value
+        end.parameterize(separator: "_")
+      end
+    end
+
+    # Serializer decides how instance attributes translate to a hash, later saved as a fixture in a YAML file.
+    class Serializer
+      attr_reader :labeler
+
+      def initialize(labeler:)
+        @labeler = labeler
+      end
+
+      def serialized_attributes_for(record:)
+        column_attributes = record.attributes.select { |a| record.class.column_names.include?(a) }
+
+        # Favour fixtures autofilled timestamps and autogenerated ids
+        filtered_attributes = %w[id created_at updated_at]
+
+        serialized_attributes = column_attributes.map do |attribute, value|
+          serialize_attribute(record, attribute, value, filtered_attributes)
+        end
+
+        serialized_attributes.sort_by(&:first).to_h.except(*filtered_attributes)
+      end
+
+      def serialize_attribute(record, attribute, value, filtered_attributes)
+        belongs_to_association = record.class.reflect_on_all_associations.filter(&:belongs_to?).find do |a|
+          a.foreign_key.to_s == attribute
+        end
+        type = record.class.type_for_attribute(attribute)
+
+        if belongs_to_association.present?
+          filter_belongs_to_columns(belongs_to_association, filtered_attributes)
+          serialize_belongs_to(record, belongs_to_association)
+        else
+          serialize_type(record, attribute, value, type)
+        end
+      end
+
+      def serialize_belongs_to(record, belongs_to_association)
+        associated_record = record.send(belongs_to_association.name)
+
+        reference_label = if belongs_to_association.polymorphic?
+                            foreign_type = record.send(belongs_to_association.foreign_type)
+                            "#{labeler.label_for(record: associated_record)} (#{foreign_type})"
+                          else
+                            labeler.label_for(record: associated_record)
+                          end
+
+        [belongs_to_association.name.to_s, reference_label]
+      end
+
+      def serialize_type(record, attribute, value, type)
+        if type.type == :datetime
+          # ActiveRecord::Type::DateTime#serialize returns a TimeWithZone object that makes the YAML dump less clear
+          [attribute, record.read_attribute_before_type_cast(attribute)]
+        elsif type.respond_to?(:serialize)
+          [attribute, type.serialize(value)]
+        else
+          [attribute, value.to_s]
+        end
+      end
+
+      def filter_belongs_to_columns(belongs_to_association, filtered_attributes)
+        filtered_attributes << belongs_to_association.foreign_key.to_s
+        return unless belongs_to_association.polymorphic?
+
+        filtered_attributes << belongs_to_association.foreign_type.to_s
+      end
+    end
+  end
+end

data/lib/fixture_champagne/railtie.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module FixtureChampagne
+  class Railtie < Rails::Railtie # :nodoc:
+    railtie_name :fixture_champagne
+
+    rake_tasks do
+      path = File.expand_path(__dir__)
+      Dir.glob("#{path}/../tasks/**/*.rake").each { |f| load f }
+    end
+  end
+end

data/lib/fixture_champagne/test_fixtures.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module FixtureChampagne
+  # TestFixtures allows access to a test database with fixtures preloaded and all fixture accessors.
+  #
+  # TestFixtures calls the ActiveRecord::TestDatabases to regenerate a test db and adapts the
+  # ActiveRecord::TestFixtures module to parse all pre existing fixtures and generate the required
+  # accessors.
+  module TestFixtures
+    extend ActiveSupport::Concern
+    include ActiveRecord::TestFixtures
+
+    included do
+      self.fixture_path = MigrationContext.fixtures_path
+      fixtures :all
+    end
+
+    def name
+      self.class.name
+    end
+
+    def before_migrate
+      # Database is already prepared
+      ActiveRecord::TestDatabases.create_and_load_schema(0, env_name: "test") unless Rails.env.test?
+
+      setup_fixtures
+    end
+
+    def after_migrate
+      teardown_fixtures
+    end
+
+    def pre_existing_fixtures
+      @loaded_fixtures
+    end
+
+    def pre_existing_fixture_sets
+      pre_existing_fixtures.map { |_k, v| v }
+    end
+
+    def pre_existing_fixture_accessors
+      # fixture_sets implementation: https://github.com/rails/rails/commit/05d80fc24f03ca5310931eacefdc247a393dd861
+      # Still not released
+      return fixture_sets.keys if respond_to?(:fixture_sets) && fixture_sets.keys.any?
+
+      fixture_table_names.map do |t_name|
+        t_name.to_s.include?("/") ? t_name.to_s.tr("/", "_") : t_name.to_s
+      end
+    end
+  end
+end

data/lib/fixture_champagne/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FixtureChampagne
+  VERSION = "0.1.0"
+end

data/lib/fixture_champagne.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "fixture_champagne/version"
+
+module FixtureChampagne # :nodoc:
+  require "fixture_champagne/railtie" if defined?(Rails)
+
+  autoload :MigrationContext, "fixture_champagne/migration_context"
+  autoload :Migrator, "fixture_champagne/migrator"
+  autoload :Migration, "fixture_champagne/migration"
+
+  class MissingMigrationsFolderError < StandardError # :nodoc:
+    def initialize
+      super("No fixture_migrations folder found in test suite folder")
+    end
+  end
+
+  class RepeatedFixtureError < StandardError; end # :nodoc:
+
+  class WrongFixtureLabelInterpolationError < StandardError # :nodoc:
+    def initialize(error_data = {})
+      super("Missing attribute or method #{error_data[:attribute]} for record class #{error_data[:klass]}")
+    end
+  end
+
+  class IllegalMigrationNameError < StandardError # :nodoc:
+    def initialize(name = nil)
+      if name
+        super("Illegal name for migration file: #{name}\n\t(only lower case letters, numbers, and '_' allowed).")
+      else
+        super("Illegal name for migration.")
+      end
+    end
+  end
+end

data/lib/generators/fixture_champagne/install_generator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module FixtureChampagne
+  module Generators
+    # InstallGenerator generates a the boilerplate necessary to use the gem.
+    #
+    # From your app directory you can run:
+    # bin/rails generate fixture_champagne:install
+    #
+    # This will create the folder set at FixtureChampagne::MigrationContext.fixture_migrations_path
+    # if it does not already exist.
+    class InstallGenerator < Rails::Generators::Base
+      desc "Setup fixture_champagne required files and folders."
+
+      def create_migrations_folder
+        return if FixtureChampagne::MigrationContext.expected_fixture_migrations_path.exist?
+
+        empty_directory FixtureChampagne::MigrationContext.expected_fixture_migrations_path
+      end
+    end
+  end
+end

data/lib/generators/fixture_champagne/migration_generator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module FixtureChampagne
+  module Generators
+    # MigrationGenerator generates a new migration using the migration.rb.tt template.
+    #
+    # Ensure that a fixture_migrations folder exists in your test suite folder or create one
+    # running the install generator. This folder is set at FixtureChampagne::MigrationContext.fixture_migrations_path
+    # Then from your app directory you can run:
+    #
+    # bin/rails generate fixture_champagne:migration <new_migration_name>
+    #
+    # Where <new_migration_name> should be the name of your new migration. For example:
+    # bin/rails generate fixture_champagne:migration add_new_user
+    #
+    # Will generate fixture_migrations/20230126153650_add_new_user.rb with the following content:
+    #   class AddTurtle < FixtureChampagne::Migration::Base
+    #     def up
+    #       # Create, update or destroy records here
+    #     end
+    #
+    #     def down
+    #       # Optionally, reverse changes made by the :up method
+    #     end
+    #   end
+    #
+    # The generator automatically adds a version number to the new migration file, which is important
+    # to keep track of executed migrations. Also, the migration filename must correspond with the migration
+    # class inside the file.
+    class MigrationGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::ResourceHelpers
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Generates a migration with the given NAME and a version."
+
+      def generate_migration
+        validate_new_migration_file_name!
+        template "migration.rb", new_migration_file_path
+      end
+
+      private
+
+      def validate_new_migration_file_name!
+        return if FixtureChampagne::Migration::MIGRATION_FILENAME_REGEXP.match?(File.basename(new_migration_file_path))
+
+        raise IllegalMigrationNameError, new_migration_file_path
+      end
+
+      def new_migration_file_path
+        fixture_migrations_path = FixtureChampagne::MigrationContext.fixture_migrations_path
+        "#{fixture_migrations_path}/#{new_migration_filename}.rb"
+      end
+
+      def new_migration_filename
+        @new_migration_filename ||= build_new_migration_filename
+      end
+
+      def build_new_migration_filename
+        new_migration_version = FixtureChampagne::Migration.new_migration_version
+        given_name = file_name
+        "#{new_migration_version}_#{given_name}"
+      end
+    end
+  end
+end

data/lib/generators/fixture_champagne/templates/migration.rb.tt

@@ -0,0 +1,9 @@
+class <%= class_name %> < FixtureChampagne::Migration::Base
+  def up
+    # Create, update or destroy records here
+  end
+
+  def down
+    # Optionally, reverse changes made by the :up method
+  end
+end

data/lib/tasks/fixture_champagne_tasks.rake

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "fixture_champagne"
+
+namespace :fixture_champagne do
+  desc "Run Fixture Champagne migrations to update fixtures"
+  task migrate: :environment  do
+    FixtureChampagne::MigrationContext.migrate
+  end
+
+  desc "Rollback Fixture Champagne last executed migration"
+  task rollback: :environment do
+    FixtureChampagne::MigrationContext.rollback
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: fixture_champagne
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Juan Gueçaimburu
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.0
+description: |
+  Data migration pattern applied to fixtures.
+  Create, update and keep fixtures synced with db schema.
+email:
+- guecaimburu.j@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/fixture_champagne.rb
+- lib/fixture_champagne/migration.rb
+- lib/fixture_champagne/migration_context.rb
+- lib/fixture_champagne/migrator.rb
+- lib/fixture_champagne/railtie.rb
+- lib/fixture_champagne/test_fixtures.rb
+- lib/fixture_champagne/version.rb
+- lib/generators/fixture_champagne/install_generator.rb
+- lib/generators/fixture_champagne/migration_generator.rb
+- lib/generators/fixture_champagne/templates/migration.rb.tt
+- lib/tasks/fixture_champagne_tasks.rake
+homepage: https://github.com/jguecaimburu/fixture_champagne
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jguecaimburu/fixture_champagne
+  source_code_uri: https://github.com/jguecaimburu/fixture_champagne
+  changelog_uri: https://github.com/jguecaimburu/fixture_champagne/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Fixture migrations for Ruby on Rails applications
+test_files: []