fixtures_from_factories 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 71e768e6b219f669c71efecbe203f358e3ab3db484045d49e297c3b6b3845f47
+  data.tar.gz: 3a18e1072c46a3d585b954e2b259ebf2ca1fbc9710f7c9e3a7ad39cdb59d912c
+SHA512:
+  metadata.gz: b607d62ff84ecf91222176ec430289057dc9075d4c5a102b69aa4a404687c4b1b768a32546dcb43d142c8667bff61bea86503bdd8cf9409581ac1ba825252299
+  data.tar.gz: 2b5fa3d3e23f2f3b1f7f67807ba52904476b66fb4f1ebcfefa50b55abf68238e43c204ed27b7b3009efe663b11dfa6934c27c5c11563c24236640f23cb6cb776

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard
+ruby_version: 2.6

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2022-11-17
+
+- Initial release

data/Gemfile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in fixtures_from_factories.gemspec
+gemspec
+
+gem "sqlite3"
+
+gem "puma"
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"
+
+gem "standard", "~> 1.3"

data/Gemfile.lock

@@ -0,0 +1,208 @@
+PATH
+  remote: .
+  specs:
+    fixtures_from_factories (0.1.0)
+      devise
+      factory_bot
+      faker
+      rails (>= 6)
+      timecop
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (7.0.4)
+      actionpack (= 7.0.4)
+      activesupport (= 7.0.4)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+    actionmailbox (7.0.4)
+      actionpack (= 7.0.4)
+      activejob (= 7.0.4)
+      activerecord (= 7.0.4)
+      activestorage (= 7.0.4)
+      activesupport (= 7.0.4)
+      mail (>= 2.7.1)
+      net-imap
+      net-pop
+      net-smtp
+    actionmailer (7.0.4)
+      actionpack (= 7.0.4)
+      actionview (= 7.0.4)
+      activejob (= 7.0.4)
+      activesupport (= 7.0.4)
+      mail (~> 2.5, >= 2.5.4)
+      net-imap
+      net-pop
+      net-smtp
+      rails-dom-testing (~> 2.0)
+    actionpack (7.0.4)
+      actionview (= 7.0.4)
+      activesupport (= 7.0.4)
+      rack (~> 2.0, >= 2.2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actiontext (7.0.4)
+      actionpack (= 7.0.4)
+      activerecord (= 7.0.4)
+      activestorage (= 7.0.4)
+      activesupport (= 7.0.4)
+      globalid (>= 0.6.0)
+      nokogiri (>= 1.8.5)
+    actionview (7.0.4)
+      activesupport (= 7.0.4)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activejob (7.0.4)
+      activesupport (= 7.0.4)
+      globalid (>= 0.3.6)
+    activemodel (7.0.4)
+      activesupport (= 7.0.4)
+    activerecord (7.0.4)
+      activemodel (= 7.0.4)
+      activesupport (= 7.0.4)
+    activestorage (7.0.4)
+      actionpack (= 7.0.4)
+      activejob (= 7.0.4)
+      activerecord (= 7.0.4)
+      activesupport (= 7.0.4)
+      marcel (~> 1.0)
+      mini_mime (>= 1.1.0)
+    activesupport (7.0.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    bcrypt (3.1.18)
+    builder (3.2.4)
+    concurrent-ruby (1.1.10)
+    crass (1.0.6)
+    devise (4.8.1)
+      bcrypt (~> 3.0)
+      orm_adapter (~> 0.1)
+      railties (>= 4.1.0)
+      responders
+      warden (~> 1.2.3)
+    erubi (1.11.0)
+    factory_bot (6.2.1)
+      activesupport (>= 5.0.0)
+    faker (2.21.0)
+      i18n (>= 1.8.11, < 2)
+    globalid (1.0.0)
+      activesupport (>= 5.0)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    json (2.6.2)
+    loofah (2.19.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.7.1)
+      mini_mime (>= 0.1.1)
+    marcel (1.0.2)
+    method_source (1.0.0)
+    mini_mime (1.1.2)
+    minitest (5.16.3)
+    net-imap (0.3.1)
+      net-protocol
+    net-pop (0.1.2)
+      net-protocol
+    net-protocol (0.1.3)
+      timeout
+    net-smtp (0.3.3)
+      net-protocol
+    nio4r (2.5.8)
+    nokogiri (1.13.9-x86_64-darwin)
+      racc (~> 1.4)
+    orm_adapter (0.5.0)
+    parallel (1.22.1)
+    parser (3.1.2.1)
+      ast (~> 2.4.1)
+    puma (6.0.0)
+      nio4r (~> 2.0)
+    racc (1.6.0)
+    rack (2.2.4)
+    rack-test (2.0.2)
+      rack (>= 1.3)
+    rails (7.0.4)
+      actioncable (= 7.0.4)
+      actionmailbox (= 7.0.4)
+      actionmailer (= 7.0.4)
+      actionpack (= 7.0.4)
+      actiontext (= 7.0.4)
+      actionview (= 7.0.4)
+      activejob (= 7.0.4)
+      activemodel (= 7.0.4)
+      activerecord (= 7.0.4)
+      activestorage (= 7.0.4)
+      activesupport (= 7.0.4)
+      bundler (>= 1.15.0)
+      railties (= 7.0.4)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.4.3)
+      loofah (~> 2.3)
+    railties (7.0.4)
+      actionpack (= 7.0.4)
+      activesupport (= 7.0.4)
+      method_source
+      rake (>= 12.2)
+      thor (~> 1.0)
+      zeitwerk (~> 2.5)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.6.0)
+    responders (3.0.1)
+      actionpack (>= 5.0)
+      railties (>= 5.0)
+    rexml (3.2.5)
+    rubocop (1.39.0)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.1.2.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.23.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.23.0)
+      parser (>= 3.1.1.0)
+    rubocop-performance (1.15.0)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.11.0)
+    sqlite3 (1.5.4-x86_64-darwin)
+    standard (1.18.0)
+      rubocop (= 1.39.0)
+      rubocop-performance (= 1.15.0)
+    thor (1.2.1)
+    timecop (0.9.5)
+    timeout (0.3.0)
+    tzinfo (2.0.5)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.3.0)
+    warden (1.2.9)
+      rack (>= 2.0.9)
+    websocket-driver (0.7.5)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeitwerk (2.6.6)
+
+PLATFORMS
+  x86_64-darwin-21
+
+DEPENDENCIES
+  fixtures_from_factories!
+  minitest (~> 5.0)
+  puma
+  rake (~> 13.0)
+  sqlite3
+  standard (~> 1.3)
+
+BUNDLED WITH
+   2.3.19

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Stephen Ierodiaconou
+
+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,124 @@
+# FixturesFromFactories
+
+A tool to help build a set of Fixtures for your Rails app, using your test suite's FactoryBot factories. 
+
+## Why? 
+
+So you can build a full set of "fake data" for your development environment or for your QA/demo or test environments.
+
+Instead of manually maintaining a set of fixtures you can write a script which uses you existing Factories to 
+build out the data set. Ie we generate fixture files from a script which uses FactoryBot factories to define the setup.
+
+`FixturesFromFactories` sets up a clean DB, runs your setup script, and then dumps records to fixture YAML files!
+
+Your Fixtures can then be very quickly loaded into the database to setup a new dev env with data to work with, or 
+reset a demo environment between demos to prospective clients.
+
+Features:
+- TODO
+
+## Prior art (`fixture-builder` gem)
+
+The logic to dump the entities to YAML is based partly on [fixture-builder](https://github.com/rdy/fixture_builder).
+
+Big thanks to the many contributors to that project.
+
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add fixtures_from_factories
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install fixtures_from_factories
+
+## Usage
+
+Write a script (rake task or otherwise) which calls `GenerateSet` and gives it the name of a class which exposes
+a "generate" method. This class should be a subclass of `FixturesFromFactories::BaseBuilder` and should
+
+```ruby
+FixturesFromFactories::GenerateSet.call(
+  DemoFixturesBuilder, # The custom class which will setup the data
+  fixtures_path, # path to the directory where the fixtures will be written, eg Rails.root.join("demos", "fixtures")
+  time_cop_now: [Time.zone.now], # The time to freeze "now" to
+  faker_seed: 42, # A seed value for faker to ensure consistent data between runs
+  options: { # Any options to pass to the data builder class, available as `options` in the builder class
+    # ...
+  }
+)
+```
+
+The `DemoFixturesBuilder` class should look something like this:
+
+```ruby
+class DemoFixturesBuilder < FixturesFromFactories::BaseBuilder
+  def generate
+    # Add data that was seeded (already in newly created database) to fixtures
+    # Here the Category records will be added with names "category_<id>"
+    generator.add_collection(Category.all)
+    # Here the tag records will be added with names "tag_<name attribute parameterized and underscored>"
+    # eg a Tag(name: "Foo Bar") will be added as "tag_foo_bar"
+    generator.add_collection(Tag.all) { |t| t.name.parameterize.underscore }
+    
+    # Setup for tables with no primary key ID (eg joins tables), note must have an AR model class
+    generator.configure_name(CategoriesPosts, :category_id, :post_id)
+
+    # Create an author
+    author = generator.create(
+      :first_author, # name of the fixture
+      :user, # factory name
+      :with_comments,  # optional traits
+      first_name: "John", # optional attributes
+      last_name: "Doe"
+    )
+    
+    # Create 6 blog posts for the author - will be named "first_author_post_1", "first_author_post_2", etc
+    generator.create_multiple(:first_author_post, :post, 1, 6) do |post_index|
+      # from the block return the attributes for the factory
+      {
+        author: author, # or generator.get(:first_author)
+        text: Faker::Lorem.paragraphs(number: 3).join("\n\n"),
+        published_at: generator.make_fake_time(post_index.days.ago, (post_index - 1).days.ago)
+      }
+    end
+    
+    generator.create(
+      :category_to_post, 
+      :categories_post, 
+      category: generator.get(:category_12), # You can get a previously created record using its name
+      post: generator.get(:first_author_post_1)
+    )
+    
+    # ... etc
+  end
+end
+```
+
+
+To load the generated fixtures to your DB
+
+    rake db:fixtures:load FIXTURES_PATH=demos/fixtures
+
+*NOTE:* if you are adding something where the records have no primary 'id' key (eg on HABTM joins table) you must
+specify the columns to use when comparing records in the generator. Ie you must specify a set of attributes
+which uniquely identify each row (for example in a join table the pair of IDs in the row). This is done in
+`TestFixturesGenerators::Index` at the start of the model generation process.
+
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/fixtures_from_factories.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "standard/rake"
+
+task default: %i[test standard]

data/lib/fixtures_from_factories/base_builder.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FixturesFromFactories
+  class BaseBuilder
+    def initialize(generator, rand_seed, options)
+      @generator = generator
+      @rand_seed = rand_seed
+      @options = options
+    end
+
+    attr_reader :generator, :options
+
+    def generate
+      raise NotImplementedError
+    end
+  end
+end

data/lib/fixtures_from_factories/fixture_generator.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: true
+
+require "factory_bot"
+require "faker"
+
+module FixturesFromFactories
+  class FixtureGenerator
+    attr_reader :model_cache, :name_config, :excluded_tables, :output_path
+
+    def initialize(
+      output_path,
+      excluded_tables = FixturesFromFactories.configuration.excluded_tables
+    )
+      @model_cache = {}
+      @name_config = {}
+      @output_path = output_path
+      @excluded_tables = excluded_tables
+    end
+
+    def generate(&blk)
+      instance_eval(&blk)
+      dump_tables
+      dump_record_index
+    end
+
+    # Record creation DSL
+
+    # Create a single named record using FactoryBot
+    def create(name_or_prefix, factory_or_index, *bot_args)
+      item_name, factory =
+        if factory_or_index.is_a?(Symbol) || factory_or_index.is_a?(Array)
+          [name_or_prefix, factory_or_index]
+        else
+          ["#{name_or_prefix}_#{factory_or_index}".to_sym, bot_args.shift]
+        end
+
+      Rails.logger.info "Creating record: #{item_name}"
+      record = FactoryBot.create(*(Array.wrap(factory) + bot_args))
+      if record.nil? || !record.persisted?
+        raise StandardError, "A record failed to save, #{record.class.name}, #{bot_args}"
+      end
+      add_record(item_name, record)
+      record
+    end
+
+    # Create multiple records from factory within index range, where the name has the index appended
+    def create_multiple(name, factory, start_index, end_index, items = nil)
+      (start_index..end_index).map.with_index do |instance_num, index|
+        bot_args = block_given? ? yield(instance_num) : items&.at(index)
+        create(name, instance_num, factory, bot_args)
+      end
+    end
+
+    def create_multiple_with_names(name_prefix, factory, names, items = nil)
+      names.map.with_index do |config, index|
+        parts = config.is_a?(Hash) ? config[:names] : config
+        n_index = Array.wrap(parts).map { |s| s.to_s.parameterize.underscore }.join("_").to_sym
+        n = "#{name_prefix}_#{n_index}".to_sym
+        bot_args = block_given? ? yield(n, n_index, config, index) : items&.at(index)
+        create(n, factory, bot_args)
+      end
+    end
+
+    # Get an existing record
+    def get(name, index = nil)
+      model_cache.fetch(index.present? ? "#{name}_#{index}".to_sym : name)[:record]
+    end
+
+    def generate_name_from_humanized(model, *parts)
+      "#{model}_#{parts.map { |s| s.to_s.parameterize.underscore }.join("_")}".to_sym
+    end
+
+    # Setup naming logic for a specific table
+    def configure_name(model_klass, *attrs)
+      name_config[model_klass.name] = {klass: model_klass, attrs: attrs}
+      name_config[model_klass.name] = ->(record, other) do
+        attrs.all? { |attr| record.attributes[attr.to_s] == other[attr.to_s] }
+      end
+    end
+
+    def add_record(item_name, record)
+      raise "Adding nil record! #{item_name}" if record.nil?
+      Rails.logger.info "Adding record #{item_name}..."
+      model_cache.merge!({item_name => cached_record(record)}) do |key|
+        raise "Duplicate key: #{key}"
+      end
+    end
+
+    def add_collection(collection, collection_name: nil)
+      c_name = collection_name || collection.name.underscore
+      added_count = 0
+      collection.find_in_batches do |group|
+        group.each do |model|
+          id = block_given? ? yield(model) : model.id.to_s
+          name = "#{c_name}_#{id}".to_sym
+          add_record(name, model)
+          added_count += 1
+        end
+      end
+      added_count
+    end
+
+    def make_fake_time(from, to)
+      Faker::Time.between(from: from.utc, to: to.utc).utc
+    end
+
+    private
+
+    def dump_record_index
+      path = File.join(output_path, "record_index.txt")
+      File.open(File.expand_path(path), "w") do |file|
+        file.write "# ----------------------------------------------------------------------------\n"
+        file.write "# Do not edit this file manually! It is generated by ./db/generate_fixtures.rb\n"
+        file.write "# ----------------------------------------------------------------------------\n"
+        file.write model_cache.keys.join("\n")
+      end
+    end
+
+    def cached_record(record)
+      {
+        record: record,
+        klass: record.class,
+        comparison: ->(record, other) do
+          if name_config[record.class.name]
+            name_config[record.class.name].call(record, other)
+          elsif record.id.present?
+            record.id.to_s == other["id"]&.to_s
+          else
+            raise StandardError,
+              "You maybe missing a call to `configure_name` for a table without a primary id key"
+          end
+        end
+      }
+    end
+
+    def class_from_table(table_name)
+      table_name.classify.constantize
+    rescue
+      nil
+    end
+
+    def get_record_name(needle, table_name)
+      generate_record_name(needle, table_name, nil)
+    end
+
+    # Based on https://github.com/rdy/fixture_builder
+    def generate_record_name(needle, table_name, row_index)
+      table_klass = class_from_table(table_name)
+      generated_name =
+        if table_klass
+          generate_record_name_with_model(needle, table_klass, row_index)
+        elsif row_index
+          [table_name, row_index.succ!].join("_")
+        end
+
+      generated_name&.to_s
+    end
+
+    def generate_record_name_with_model(needle, table_klass, row_index)
+      found_name = get_record_name_from_cache(needle, table_klass)
+      if found_name.present?
+        found_name
+      elsif row_index
+        [table_klass.name, row_index.succ!].join("_")
+      end
+    end
+
+    def get_record_name_from_cache(needle, table_klass)
+      # Check if the model is in the cache and get its name, otherwise generate a name from a sequence
+      # Note if row_index is not set and the model isnt in the cache (ie it was not explicitly created by us) then
+      # nil is returned
+      klasses = [table_klass]
+      klasses.concat(table_klass.subclasses) if table_klass.subclasses.present?
+      found_name =
+        model_cache.find do |_key, cached|
+          klasses.include?(cached[:klass]) && cached[:comparison].call(cached[:record], needle)
+        end
+      found_name&.first
+    end
+
+    # Taken from https://github.com/rdy/fixture_builder
+    def tables
+      ActiveRecord::Base.connection.tables - excluded_tables
+    end
+
+    # Based on https://github.com/rdy/fixture_builder but we replace references with a named reference and let Rails
+    # generate stable IDs. In cases where a record has been created indirectly by a factory (and not explicity by this
+    # generator) it will stay as a reference with a hardcoded ID
+    def dump_tables
+      default_date_format = Date::DATE_FORMATS[:default]
+      Date::DATE_FORMATS[:default] = Date::DATE_FORMATS[:db]
+      begin
+        fixtures =
+          tables.inject([]) do |files, table_name|
+            rows = process_table(table_name)
+            next files if rows.empty?
+
+            fixture_data = prepare_fixture_data(rows, table_name)
+            write_fixture_file(fixture_data, table_name)
+            files + [File.basename(fixture_file(table_name))]
+          end
+      ensure
+        Date::DATE_FORMATS[:default] = default_date_format
+      end
+      Rails.logger.info "Built #{fixtures.to_sentence}"
+    end
+
+    def process_table(table_name)
+      table_klass = class_from_table(table_name)
+      if table_klass && table_klass < ActiveRecord::Base
+        process_table_with_model(table_klass)
+      else
+        process_table_without_model(table_name)
+      end
+    end
+
+    def process_table_with_model(table_klass)
+      table_klass.unscoped do
+        table_klass.all.map do |obj|
+          attrs = obj.attributes.select { |attr_name| table_klass.column_names.include?(attr_name) }
+          attrs.each_with_object({}) do |(attr_name, value), hash|
+            replace_association_with_named(table_klass, attrs, hash, attr_name, value)
+          end
+        end
+      end
+    end
+
+    # Some records are
+    def replace_association_with_named(table_klass, attrs, hash, attr_name, value)
+      # If the record attribute is a relation, then get the other model name and use it instead of a ID value
+      # but only if there is a AR model for the table
+      attr_name_without_id = attr_name.sub(/_id$/, "")
+      reflection = table_klass.reflect_on_association(attr_name_without_id)
+      if reflection&.kind_of?(ActiveRecord::Reflection::AssociationReflection) && value.present?
+        related_klass_name =
+          begin
+            # Polymorphic
+            association_type = attrs[attr_name_without_id + "_type"]
+            association_type.presence || reflection.class_name
+          end
+        other_name = get_record_name({"id" => value}, related_klass_name.constantize.table_name)
+        if other_name
+          hash[attr_name_without_id] = other_name.to_s
+          return hash
+        end
+      end
+      hash[attr_name] = serialized_value_if_needed(table_klass, attr_name, value)
+    end
+
+    # Some tables have no model (eg joins) and should be dumped.
+    def process_table_without_model(table_name)
+      ActiveRecord::Base
+        .connection
+        .select_all(
+          "SELECT * FROM %<table>s" % {
+            table: ActiveRecord::Base.connection.quote_table_name(table_name)
+          }
+        )
+        .map do |row|
+          row.each_with_object({}) do |(attr_name, value), hash|
+            # If the record attribute is a relation, then get the other model name and use it instead of a ID value
+            if attr_name.end_with?("_id") && value.present?
+              attr_name_without_id = attr_name.sub(/_id$/, "")
+              klass = class_from_table(attr_name_without_id)
+              if klass
+                other_name = get_record_name({"id" => value}, klass.table_name)
+
+                # Note when there is no model for the table then retain '_id' attr name, as the fixtures setup code
+                # doesnt know about a relation named with the value of <attr_name_without_id> since there is no Model class
+                hash[attr_name] = other_name ? other_name.to_s : value
+              else
+                hash[attr_name] = value
+              end
+            else
+              hash[attr_name] = value
+            end
+          end
+        end
+    end
+
+    def prepare_fixture_data(rows, table_name)
+      # This will be mutated by calls to generate_record_name in cases where the index is needed
+      row_index = +"000"
+      rows.inject({}) do |hash, record|
+        # If this was created by us, dont store the ID, use the rails stable ID
+        obj_name = get_record_name(record, table_name)
+        record_name = generate_record_name(record, table_name, row_index)
+        if obj_name
+          Rails.logger.debug "Writing #{obj_name} (#{table_name})"
+          record.delete("id")
+        else
+          Rails
+            .logger.debug "Writing a record which was created indirectly by a factory (#{table_name})"
+        end
+        hash.merge(record_name => record)
+      end
+    end
+
+    # Taken from https://github.com/rdy/fixture_builder
+    def serialized_value_if_needed(table_klass, attr_name, value)
+      if table_klass.respond_to?(:type_for_attribute)
+        serialize_according_to_type(table_klass, attr_name, value)
+      elsif table_klass.serialized_attributes.has_key? attr_name
+        table_klass.serialized_attributes[attr_name].dump(value)
+      else
+        value
+      end
+    end
+
+    def serialize_according_to_type(klass, attr_name, value)
+      attr_type = klass.type_for_attribute(attr_name)
+      if attr_type.type == :jsonb || attr_type.type == :json
+        value
+      elsif attr_type.type == :time
+        # Serialise as an ActiveSupport::TimeWithZone
+        value
+      elsif attr_type.respond_to?(:serialize)
+        attr_type.serialize(value)
+      elsif attr_type.respond_to?(:type_cast_for_database)
+        attr_type.type_cast_for_database(value)
+      else
+        attr_type.type_cast_for_schema(value)
+      end
+    end
+
+    def write_fixture_file(fixture_data, table_name)
+      File.open(fixture_file(table_name), "w") do |file|
+        file.write "# ----------------------------------------------------------------------------\n"
+        file.write "# Do not edit this file manually! It is generated by ./db/generate_fixtures.rb\n"
+        file.write "# ----------------------------------------------------------------------------\n"
+        file.write fixture_data.to_yaml
+      end
+    end
+
+    def fixture_file(table_name)
+      File.expand_path(File.join(output_path, "#{table_name}.yml"))
+    end
+  end
+end

data/lib/fixtures_from_factories/generate_set.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "./fixture_generator"
+require "timecop"
+
+module FixturesFromFactories
+  class GenerateSet
+    class << self
+      def call(generator_index_klass, output_path, time_cop_now:, faker_seed:, options: {})
+        raise "Do not run fixture generation in a production environment" if ::Rails.env.production?
+
+        # Seed with known value to always end up with same result
+        ::Faker::Config.random = Random.new(faker_seed)
+        ::Faker::Config.locale = "en"
+
+        # Freeze the time to avoid having changing timestamps when regenerating
+        ::Timecop.freeze(*time_cop_now)
+
+        # TODO: what is a better solution here?
+        # Monkey patch Devise encryptor so that we generate stable password hashes
+        if defined?(Devise)
+          ::Devise::Encryptor.define_singleton_method(:digest) do |_klass, _password|
+            FixturesFromFactories.configuration.devise_password_hash
+          end
+        end
+
+        database_env_setup = "RAILS_ENV=#{ENV["RAILS_ENV"]}"
+        puts "Setup database for fixtures #{database_env_setup}"
+        system("#{database_env_setup} bin/rails db:environment:set RAILS_ENV=development")
+        # TODO: should we just use db:reset here?
+        system("#{database_env_setup} rake db:drop")
+        system("#{database_env_setup} rake db:create")
+        system("#{database_env_setup} rake db:migrate")
+        system("#{database_env_setup} rake db:seed")
+
+        if FixturesFromFactories.configuration.factory_bot_definition_file_paths
+          FactoryBot.definition_file_paths = FixturesFromFactories.configuration.factory_bot_definition_file_paths
+        end
+        FactoryBot.find_definitions
+
+        # Prepare the fixture files
+        FixtureGenerator.new(output_path).generate do
+          generator_index_klass.new(self, faker_seed, options).generate
+        end
+
+        # After fixtures are build the Rails env set in the DB is lost, so set it manually
+        system("#{database_env_setup} bin/rails db:environment:set RAILS_ENV=development")
+
+        ::Timecop.return
+      end
+    end
+  end
+end

data/lib/fixtures_from_factories/railtie.rb

@@ -0,0 +1,7 @@
+module FixturesFromFactories
+  class Railtie < ::Rails::Railtie
+    # rake_tasks do
+    #   load "tasks/fixtures_from_factories.rake"
+    # end
+  end
+end

data/lib/fixtures_from_factories/version.rb

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

data/lib/fixtures_from_factories.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "fixtures_from_factories/version"
+require_relative "fixtures_from_factories/base_builder"
+require_relative "fixtures_from_factories/fixture_generator"
+require_relative "fixtures_from_factories/generate_set"
+require_relative "fixtures_from_factories/railtie"
+
+module FixturesFromFactories
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+      configuration
+    end
+  end
+
+  # Configuration class for initializer
+  class Configuration
+    # @dynamic devise_password_hash
+    attr_accessor :devise_password_hash, :excluded_tables, :factory_bot_definition_file_paths
+
+    def initialize
+      @devise_password_hash = "$2a$11$M8e7PEPxv4JEx2JHLw4XnuvfVVafJjFb6DfMnODxSUy5WhIgfbF1y" # 'password' TODO: make this not use the hashed value but let it be hashed at creation time
+      @excluded_tables = %w[schema_migrations spatial_ref_sys ar_internal_metadata]
+      @factory_bot_definition_file_paths = nil
+    end
+  end
+end

data/sig/fixtures_from_factories.rbs

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

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: fixtures_from_factories
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Stephen Ierodiaconou
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: devise
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A tool to help build a set of Fixtures for your Rails app, using your
+  test suite's FactoryBot factories. .
+email:
+- stevegeek@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/fixtures_from_factories.rb
+- lib/fixtures_from_factories/base_builder.rb
+- lib/fixtures_from_factories/fixture_generator.rb
+- lib/fixtures_from_factories/generate_set.rb
+- lib/fixtures_from_factories/railtie.rb
+- lib/fixtures_from_factories/version.rb
+- sig/fixtures_from_factories.rbs
+homepage: https://github.com/stevegeek/fixtures_from_factories
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/stevegeek/fixtures_from_factories
+  source_code_uri: https://github.com/stevegeek/fixtures_from_factories
+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.7
+signing_key:
+specification_version: 4
+summary: Build a set of Fixtures for your Rails app, using your test suite's FactoryBot
+  factories.
+test_files: []