fixture_seed 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b756a4004e83e2c69aac4a24fc69391e646fafa774d79b547b65b8d6fa58df7
-  data.tar.gz: 7790869a088bd54a43a5881da34885c7b79c9ea0360c6601ef0314e34d925067
+  metadata.gz: f0e74af85ef70b7b2f6e72ddcb76f79b91c1d51687035b795b194fca9707ac2a
+  data.tar.gz: d6fc5b8f08ebf31474ad2c59a16332b387b5b81e28cf0e47392bfb60f897fa57
 SHA512:
-  metadata.gz: 70a2b5e3514bef02dccec7ad3ecb97b7cc7742236838531ba7688b8f54884c3b57cd796dbea9828ac261453ba896c308088b9a308f2cdbc49fce1e406247961e
-  data.tar.gz: 469c9859bd06c963550e6426df5c6cf2805f795abacf3a56863b6b695302d5a2fb8edc07b1c4d87770f2f51e5721693a1e5e530ba6cd8efec36e7afcf6168294
+  metadata.gz: 64f239553428392fe6f7cc7c0571ac0ddf0b232abb279869ff394550743c834f2474f14310075b44ca9684125c7c09b045aa768d0bf1d94be11ead4d17d0bbf4
+  data.tar.gz: 78e4a7afcbd6829371d8349827ce40647c5fb70021ffbb93336decddd9a7d59c6bdb01010c81e2a2fd9ba943e0049ebefdd8355d166886f08689a4b5f395edad

data/README.md

@@ -1,6 +1,6 @@
 # FixtureSeed
 
-FixtureSeed is a Rails gem that automatically loads YAML fixture files from the `db/fixtures/` directory when running `rails db:seed`. It loads the fixtures in alphabetical order and handles foreign key constraint errors by retrying failed inserts after all other fixtures are loaded.
+FixtureSeed is a Rails gem that automatically loads YAML fixture files from the `db/fixtures/` directory before running `rails db:seed`. It loads the fixtures in alphabetical order and handles foreign key constraint errors by retrying failed inserts after all other fixtures are loaded.
 
 ## Installation
 
@@ -52,9 +52,54 @@ user2:
 
 The labels (e.g., `user1`, `user2`) should follow the pattern of the table name in singular form followed by a number.
 
-### Loading Order
+#### ERB Support
 
-Fixtures are loaded in alphabetical order by filename. However, if a fixture fails to load due to foreign key constraints, it will be retried after all other fixtures have been processed.
+For dynamic fixture generation, you can use ERB templates in your YAML files:
+
+```erb
+# users.yml
+<% 10.times do |i| %>
+user<%= i + 1 %>:
+  id: <%= i + 1 %>
+  name: "User <%= i + 1 %>"
+  email: "user<%= i + 1 %>@example.com"
+  created_at: <%= Time.current.to_s(:db) %>
+<% end %>
+```
+
+ERB templates have access to the full Rails environment, allowing you to use helpers, constants, and other Ruby code to generate dynamic fixture data.
+
+### Fixture Loading Order
+
+#### Order-independent Loading
+
+FixtureSeed supports **order-independent loading**, which means you don't need to worry about the loading order of your fixture files based on database relationships.
+
+#### How it works
+
+1. Fixtures are initially loaded in alphabetical order by filename
+2. When a fixture fails to load due to foreign key constraints, it's automatically retried later
+3. The gem continues processing other fixtures and comes back to failed ones
+4. This process repeats until all fixtures are loaded or no progress can be made
+
+#### Benefits
+
+- **No manual dependency management**: You don't need to rename files or organize them based on foreign key relationships
+- **Simplified fixture organization**: Focus on logical grouping rather than loading order
+- **Robust loading**: Handles complex relationships automatically
+- **Error resilience**: Temporary constraint violations don't stop the entire process
+
+#### Example
+
+Even if your fixtures have dependencies like this:
+```
+db/fixtures/
+  comments.yml    # depends on posts and users
+  posts.yml       # depends on users  
+  users.yml       # no dependencies
+```
+
+FixtureSeed will automatically handle the loading order, ensuring `users.yml` loads first, then `posts.yml`, and finally `comments.yml`, regardless of alphabetical order.
 
 ## Development
 

data/lib/fixture_seed/loader.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module FixtureSeed
+  class Loader
+    class << self
+      def load_fixtures(fixtures_path = nil)
+        fixtures_path ||= ENV["FIXTURES_PATH"] || "db/fixtures"
+        fixtures_dir = Rails.root.join(fixtures_path)
+
+        unless Dir.exist?(fixtures_dir)
+          logger = Rails.logger || Logger.new($stdout)
+          logger.info "[FixtureSeed] Fixtures directory not found: #{fixtures_path}"
+          return
+        end
+
+        logger = Rails.logger || Logger.new($stdout)
+        logger.info "[FixtureSeed] Loading fixtures from #{fixtures_path}"
+
+        ActiveRecord::Base.transaction do
+          with_foreign_keys_disabled do
+            load_fixture_files(fixtures_dir, logger)
+          end
+        end
+
+        logger.info "[FixtureSeed] Finished loading fixtures"
+      end
+
+      private
+
+      def load_fixture_files(fixtures_dir, logger)
+        fixture_files = Dir.glob("#{fixtures_dir}/*.yml")
+        return if fixture_files.empty?
+
+        table_names = fixture_files.map { |f| File.basename(f, ".yml") }
+        logger.info "[FixtureSeed] Found tables: #{table_names.join(', ')}"
+
+        ordered_tables = dependency_ordered_tables(table_names)
+
+        ordered_tables.each do |table_name|
+          ActiveRecord::FixtureSet.create_fixtures(fixtures_dir.to_s, [table_name])
+        end
+      end
+
+      def dependency_ordered_tables(table_names)
+        ordered = []
+        ordered << "users" if table_names.include?("users")
+        ordered += (table_names - ["users"])
+        ordered
+      end
+
+      def with_foreign_keys_disabled
+        adapter_name = ActiveRecord::Base.connection.adapter_name.downcase
+
+        disable_foreign_keys(adapter_name)
+        yield
+      ensure
+        enable_foreign_keys(adapter_name)
+      end
+
+      def disable_foreign_keys(adapter_name)
+        case adapter_name
+        when /postgresql/
+          ActiveRecord::Base.connection.execute("SET session_replication_role = replica;")
+        when /sqlite/
+          ActiveRecord::Base.connection.execute("PRAGMA foreign_keys = OFF;")
+        when /mysql/
+          ActiveRecord::Base.connection.execute("SET FOREIGN_KEY_CHECKS = 0;")
+        end
+      end
+
+      def enable_foreign_keys(adapter_name)
+        case adapter_name
+        when /postgresql/
+          ActiveRecord::Base.connection.execute("SET session_replication_role = DEFAULT;")
+        when /sqlite/
+          ActiveRecord::Base.connection.execute("PRAGMA foreign_keys = ON;")
+        when /mysql/
+          ActiveRecord::Base.connection.execute("SET FOREIGN_KEY_CHECKS = 1;")
+        end
+      end
+    end
+  end
+end

data/lib/fixture_seed/railtie.rb

@@ -1,21 +1,18 @@
 # frozen_string_literal: true
 
+require_relative "loader"
+
 module FixtureSeed
   class Railtie < Rails::Railtie
-    initializer "fixture_seed.initialize" do
-      Rails.logger.info "[FixtureSeed] Railtie initialized"
-    end
-
     rake_tasks do
-      if Rake::Task.task_defined?("db:seed")
-        Rake::Task["db:seed"].enhance do
-          Rails.logger.info "[FixtureSeed] Starting to load fixtures through db:seed enhancement"
-          FixtureSeed.load_fixtures
-          Rails.logger.info "[FixtureSeed] Finished loading fixtures"
+      namespace :fixture_seed do
+        desc "Load fixtures from specified directory"
+        task load_fixtures: :environment do
+          FixtureSeed::Loader.load_fixtures
         end
-      else
-        Rails.logger.warn "[FixtureSeed] db:seed task not found, fixture loading enhancement not applied"
       end
+
+      Rake::Task["db:seed"].enhance(["fixture_seed:load_fixtures"]) if Rake::Task.task_defined?("db:seed")
     end
   end
 end

data/lib/fixture_seed/version.rb

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

data/lib/fixture_seed.rb

@@ -1,106 +1,13 @@
 # frozen_string_literal: true
 
 require_relative "fixture_seed/version"
+require_relative "fixture_seed/loader"
 require_relative "fixture_seed/railtie" if defined?(Rails::Railtie)
 
 module FixtureSeed
   class Error < StandardError; end
 
-  class << self
-    def load_fixtures
-      fixture_dir = Rails.root.join("db/fixtures").to_s
-      files_to_load = Dir.glob(File.join(fixture_dir, "*.yml")).sort
-
-      file_names = files_to_load.map { |f| File.basename(f) }.join(", ")
-      Rails.logger.info "[FixtureSeed] Found #{files_to_load.size} fixture files in #{fixture_dir}: #{file_names}"
-
-      # Load all fixtures with retry logic
-      unloaded_files = process_fixtures(fixture_dir, files_to_load)
-
-      # Report any fixtures that still failed
-      if unloaded_files.empty?
-        Rails.logger.info "[FixtureSeed] All fixtures loaded successfully."
-      else
-        message = "The following fixtures could not be loaded: #{unloaded_files.join(', ')}"
-        Rails.logger.warn "[FixtureSeed] #{message}"
-      end
-    end
-
-    private
-
-    def process_fixtures(fixture_dir, files)
-      remaining_files = files.dup
-      previous_count = remaining_files.size + 1
-
-      # Continue until all fixtures are loaded or no progress is made
-      while !remaining_files.empty? && remaining_files.size < previous_count
-        previous_count = remaining_files.size
-        remaining_files = process_batch(fixture_dir, files, remaining_files)
-      end
-
-      remaining_files
-    end
-
-    def process_batch(fixture_dir, original_files, current_files)
-      still_failed = []
-
-      current_files.each do |file|
-        log_loading(file)
-        load_single_fixture(fixture_dir, file)
-        log_success(file, original_files, current_files)
-      rescue ActiveRecord::InvalidForeignKey, ActiveRecord::StatementInvalid => e
-        log_failure(file, e, original_files, current_files)
-        still_failed << file
-      end
-
-      still_failed
-    end
-
-    def load_single_fixture(_fixture_dir, file)
-      table_name = File.basename(file, ".yml")
-      yaml_data = YAML.load_file(file)
-
-      model_class = begin
-        table_name.classify.constantize
-      rescue StandardError
-        nil
-      end
-
-      if model_class
-        yaml_data.each do |_fixture_name, attributes|
-          model_class.create!(attributes)
-        rescue StandardError => e
-          raise ActiveRecord::InvalidForeignKey, e.message
-        end
-      else
-        Rails.logger.warn "[FixtureSeed] Model for table #{table_name} not found"
-      end
-    end
-
-    def log_loading(file)
-      table_name = File.basename(file, ".yml")
-      Rails.logger.info "[FixtureSeed] Loading fixture #{File.basename(file)}..."
-    end
-
-    def log_success(file, original_files, current_files)
-      is_retry = original_files.size != current_files.size
-      if is_retry
-        Rails.logger.info "[FixtureSeed] Successfully loaded fixture #{File.basename(file)} on retry."
-      else
-        Rails.logger.info "[FixtureSeed] Loaded fixture #{File.basename(file)}"
-      end
-    end
-
-    def log_failure(file, error, original_files, current_files)
-      is_retry = original_files.size != current_files.size
-      filename = File.basename(file)
-      if is_retry
-        Rails.logger.warn "[FixtureSeed] Still failed to load fixture #{filename}: " \
-                          "#{error.message}. Will retry later."
-      else
-        Rails.logger.warn "[FixtureSeed] Failed to load fixture #{filename}: " \
-                          "#{error.message}. Will retry later."
-      end
-    end
+  def self.load_fixtures(fixtures_path = nil)
+    Loader.load_fixtures(fixtures_path)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fixture_seed
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Masaki Komagata
@@ -36,6 +36,7 @@ files:
 - LICENSE.txt
 - README.md
 - lib/fixture_seed.rb
+- lib/fixture_seed/loader.rb
 - lib/fixture_seed/railtie.rb
 - lib/fixture_seed/version.rb
 - sig/fixture_seed.rbs