seed_builder 1.2.1 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a607759220852d1d00fcfe17bce2c9d419446a3bfa066c446e85121a11e70f17
-  data.tar.gz: d02f1a778d953c5a48a6862a64b9bf4dd2dec73118c066865aec91399ff6b2e6
+  metadata.gz: 6e17c7224d3dede956d465e3d7c81d45fadfae50481fad4f68fc0d5aee8d2936
+  data.tar.gz: a0bea568dc1e39af05473f5614ecd7f7337328ab191ce86de7f7ae1632e51615
 SHA512:
-  metadata.gz: 9c731f5ed5c7644f27a475122aedc0f48c32d17c27f3034473fc6b6a127808b25c5d016275ccdf4d36743414d7928706fad046e9d1704a6dc08de5a2dd8475c0
-  data.tar.gz: 90f6e27dd1bd7022f940261181a1308fe3ff8a2efd42b932914dd44419d438f2abafaf33650a68cd9b6ab8386235041add92ecc1126b6b74d39294139304adf3
+  metadata.gz: 7cd7abeb732f00b1a226caa1cc2793c9bb403e416ca85886ee72232b70eac6d33c81f3b1e7df88a3dc8eeecc798c0e0497254e3a5e9ab85eb3aa2d97199dc3b1
+  data.tar.gz: 4ea91653aae9ab4216311fbf9da32a649595ced5e128632ed095e7dcd8c8ff1d0b19a79ab0e7fe23354abb2740f9864886fc90e3bc92d970f0fead5216e5ceb3

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # CHANGELOG
 
+## 1.3.1 (2026-11-03)
+
+- Use updated seed paths after configuration has already been read.
+- Load the application's Rails environment when running the seed command.
+- Exclude development tools and audit records from the installed gem.
+- Cancel release preparation when confirmation input is closed.
+- Run timestamped seed files in numeric timestamp order.
+- Fail `bin/seed` and `bin/rails seed:run` when the seed is missing, ambiguous, invalid, or outside the seeds directory.
+- Reject an invalid or missing seed name before opening a database connection.
+- Warn that the seed directory is missing only when directory loading is enabled.
+- Keep `bin/rails db:seed` on the Rails seed file when `SeedBuilder.config.use_seed_loader` is false.
+
+## 1.3.0 (2025-11-04)
+
+- Replace `puts` statements with `Rails.logger` for proper logging integration
+- Add tagged logging with `seed` tag for all seed-related log messages
+- Add `logger` configuration option to allow custom logger setup via `SeedBuilder.config.logger = custom_logger`
+- Fix seed file loading to use `load` instead of `require` to ensure files are re-executed on each seed run
+- Logger automatically detects if `Rails.logger` already supports tagging to avoid double-wrapping
+- Add ability to run specific seed files on demand using `bin/rails seed:run[SEED_NAME]`
+- Add `load_seed_file` method to `SeedBuilder::Loader` for loading individual seeds
+- Add ambiguous match detection: when multiple seed files match the same name, the loader lists the matches and the command needs the full name with the timestamp
+- Patch `Rails.application.load_seed` to use SeedBuilder loader via Railtie integration
+
 ## 1.2.1
 
 - Fix seed files to be loaded as `.rb` files

data/README.md

@@ -1,10 +1,8 @@
 # seed_builder.rb
 
-[![Gem Version](https://badge.fury.io/rb/seed_builder.svg)](https://badge.fury.io/rb/seed_builder) [![Test Status](https://github.com/amkisko/seed_builder.rb/actions/workflows/test.yml/badge.svg)](https://github.com/amkisko/seed_builder.rb/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/amkisko/seed_builder.rb/graph/badge.svg?token=57R6OHOJDQ)](https://codecov.io/gh/amkisko/seed_builder.rb)
+[![Gem Version](https://badge.fury.io/rb/seed_builder.svg)](https://badge.fury.io/rb/seed_builder) [![Test Status](https://github.com/amkisko/seed_builder.rb/actions/workflows/test.yml/badge.svg)](https://github.com/amkisko/seed_builder.rb/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/amkisko/seed_builder.rb/graph/badge.svg?token=57R6OHOJDQ)](https://app.codecov.io/github/amkisko/seed_builder.rb)
 
-Seed builder for ActiveRecord. Includes seeds loader and generator.
-
-Sponsored by [Kisko Labs](https://www.kiskolabs.com).
+Seed loader and generator for ActiveRecord.
 
 ## Installation
 
@@ -30,10 +28,31 @@ gem "seed_builder"
 
 ### Run seeds
 
+Run all seeds:
+
 ```sh
 bin/rails db:seed
 ```
 
+Or in code:
+
+```ruby
+Rails.application.load_seed
+```
+
+Run a specific seed file:
+
+```sh
+bin/rails seed:run[create_users]
+```
+
+You can specify the seed name in different formats:
+- Class name: `create_users` (matches `20241206200111_create_users.rb`)
+- Full name: `20241206200111_create_users`
+- Timestamp: `20241206200111`
+
+If several seed files match the same name, the command writes the matching names to the log and exits with status 1. Run it again with the timestamped name, for example `20241206200111_create_users`. `bin/seed` uses the same names and the same failed status.
+
 ### Generate seed file
 
 ```sh
@@ -46,7 +65,7 @@ bin/rails g seed create_users
 
 By default seed file `db/seeds.rb` is loaded.
 
-To turn off loading default seeds.rb file:
+To stop loading `db/seeds.rb`:
 
 ```ruby
 SeedBuilder.config.load_default_seeds = false
@@ -54,7 +73,7 @@ SeedBuilder.config.load_default_seeds = false
 
 ### Set seed directory
 
-Absolute path will be resolved by using `Rails.root`.
+A relative `seeds_path` is joined to `Rails.root`. An absolute `seeds_path` is used as given. Set `seeds_full_path` to select the directory directly.
 
 ```ruby
 SeedBuilder.config.seeds_path = "db/seeds"
@@ -72,45 +91,123 @@ SeedBuilder.config.generate_spec = false
 SeedBuilder.config.use_seed_loader = false
 ```
 
+### Set custom logger
+
+By default, SeedBuilder uses `Rails.logger` (or falls back to `Logger.new($stdout)` if Rails is not available). All seed-related log messages are tagged with `[seed]`.
+
+To use a custom logger:
+
+```ruby
+SeedBuilder.config.logger = MyCustomLogger.new
+```
+
+SeedBuilder wraps that logger with `ActiveSupport::TaggedLogging` when the logger has no `tagged` method, so the `[seed]` tag is present.
+
 ## Specification checklist
 
 - [x] User can generate seed file under `db/seeds` directory with common format
 - [x] User can generate seed file with test script included
 - [x] User can run all seeds
-- [ ] User can run specific seed file
+- [x] User can run specific seed file
+
+## Limitations
+
+- `bin/rails db:seed` calls `ActiveRecord::Tasks::DatabaseTasks.load_seed`, which calls `Rails.application.load_seed`. The railtie replaces `load_seed` while `use_seed_loader` is on. Set `use_seed_loader = false` in an initializer, before the application finishes booting, to keep the Rails seed file.
+- The ActiveRecord migration generator writes the seed files.
+- A seed run is not reversed. Write seed files so they can run more than once, for example by checking that a record is already present.
+- A seed file is not a migration.
+
+## Development
+
+```bash
+# Install dependencies
+bundle install
+bundle exec appraisal generate
 
-## Limitations & explanations
+# Run tests for current Rails version
+bundle exec polyrun parallel-rspec --workers 5 --merge-failures
 
-- Gem patches `ActiveRecord::Tasks::DatabaseTasks.seed_loader` to have custom loader
-- ActiveRecord migrations generator is used to generate seed files
-- Seeded data is not reversible, there is no point to implement it as logic can be complex and operations on data might lead to irreversible changes
-- Seed file is not a migration, although as good practice is to keep it idempotent, e.g. by checking uniqueness of seeded records
+# Run tests for the configured Rails versions (7.2 and 8.1)
+bin/appraisals
+
+# Run tests for Rails 7.2
+bin/appraisals rails72
+
+# Run tests for Rails 7.2 and Rails 8.1 on Ruby 3.4
+bin/appraisals rails72 rails8ruby34
+
+# Or use appraisal directly
+bundle exec appraisal rails72 rspec
+
+# Run linter
+bundle exec standardrb --fix
+
+# Check type signatures
+bundle exec rbs validate
+```
+
+### Development: Using from Local Repository
+
+When developing the gem or testing changes in your application, you can point your Gemfile to a local path:
+
+```ruby
+# In your application's Gemfile
+gem "seed_builder", path: "../seed_builder.rb"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+With `path:` in the Gemfile, Bundler loads this checkout. Edits in the checkout are what the application runs, without a rebuild or reinstall.
 
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at <https://github.com/amkisko/seed_builder.rb>
 
 Contribution policy:
-
 - New features are not necessarily added to the gem
 - Pull request should have test coverage for affected parts
 - Pull request should have changelog entry
+
+Review policy:
 - It might take up to 2 calendar weeks to review and merge critical fixes
 - It might take up to 6 calendar months to review and merge pull request
 - It might take up to 1 calendar year to review an issue
 
 ## Publishing
 
-Prefer using script `usr/bin/release.sh`, it will ensure that repository is synced and after publishing gem will create a tag.
+From a clean checkout, run:
 
 ```sh
-GEM_VERSION=$(grep -Eo "VERSION\s*=\s*\".+\"" lib/seed_builder.rb  | grep -Eo "[0-9.]{5,}")
-rm seed_builder-*.gem
-gem build seed_builder.gemspec
-gem push seed_builder-$GEM_VERSION.gem
-git tag $GEM_VERSION && git push --tags
+ruby usr/bin/release.rb
 ```
 
+The script installs dependencies, runs the test suite, requires a clean worktree, checks the changelog heading, and asks before publishing. On confirmation it pushes the gem, tags that version, and opens a GitHub release.
+
+## Links
+
+- [GitHub](https://github.com/amkisko/seed_builder.rb)
+- [GitLab](https://gitlab.com/amkisko/seed_builder.rb)
+- [RubyGems](https://rubygems.org/gems/seed_builder)
+- [Versions Atom](https://rubygems.org/gems/seed_builder/versions.atom) (feed id `8140233409492`)
+- [libraries.io](https://libraries.io/rubygems/seed_builder)
+- [Deps.dev](https://deps.dev/rubygems/seed_builder)
+- [SonarCloud](https://sonarcloud.io/project/overview?id=amkisko_seed_builder.rb)
+- [Snyk](https://snyk.io/test/github/amkisko/seed_builder.rb)
+- [Codecov](https://app.codecov.io/github/amkisko/seed_builder.rb)
+- [OpenSSF Scorecard](https://scorecard.dev/viewer/?uri=github.com/amkisko/seed_builder.rb)
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Sponsors
+
+Sponsored by [Kisko Labs](https://www.kiskolabs.com).
+
+<a href="https://www.kiskolabs.com">
+  <img src="kisko.svg" width="200" alt="Sponsored by Kisko Labs" />
+</a>

data/bin/seed

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+environment = File.expand_path("config/environment.rb", Dir.pwd)
+require environment if File.file?(environment)
+
+unless defined?(Rails)
+  puts "Error: Rails environment not loaded. Please run this from a Rails application root."
+  puts "Alternatively, use: bin/rails seed:run[SEED_NAME]"
+  exit 1
+end
+
+require "seed_builder"
+
+if ARGV.empty?
+  puts "Usage: bin/seed SEED_NAME"
+  puts ""
+  puts "Run a specific seed file by name."
+  puts ""
+  puts "Examples:"
+  puts "  bin/seed create_users"
+  puts "  bin/seed 20241206200111_create_users"
+  puts "  bin/seed 20241206200111"
+  puts ""
+  puts "Note: This script must be run from a Rails application root."
+  puts "      If multiple seed files match the name, use the full name with"
+  puts "      timestamp to avoid ambiguity (e.g., 20241206200111_create_users)."
+  puts ""
+  puts "Alternatively, use: bin/rails seed:run[SEED_NAME]"
+  exit 1
+end
+
+seed_name = ARGV[0]
+
+loader = SeedBuilder::Loader.new
+exit 1 unless loader.load_seed_file(seed_name)
+

data/lib/seed_builder/config.rb

@@ -7,7 +7,7 @@ module SeedBuilder
 
     attr_writer :default_seeds_full_path
     def default_seeds_full_path
-      @default_seeds_full_path ||= Rails.root.join(default_seeds_path)
+      @default_seeds_full_path || Rails.root.join(default_seeds_path)
     end
 
     attr_writer :seeds_path
@@ -17,7 +17,7 @@ module SeedBuilder
 
     attr_writer :seeds_full_path
     def seeds_full_path
-      @seeds_full_path ||= Rails.root.join(seeds_path)
+      @seeds_full_path || Rails.root.join(seeds_path)
     end
 
     def seeds_path_glob
@@ -26,22 +26,24 @@ module SeedBuilder
 
     attr_writer :load_default_seeds
     def load_default_seeds?
-      @load_default_seeds.nil? ? true : @load_default_seeds
+      @load_default_seeds.nil? || @load_default_seeds
     end
 
     attr_writer :load_seeds
     def load_seeds?
-      @load_seeds.nil? ? true : @load_seeds
+      @load_seeds.nil? || @load_seeds
     end
 
     attr_writer :generate_spec
     def generate_spec?
-      @generate_spec.nil? ? true : @generate_spec
+      @generate_spec.nil? || @generate_spec
     end
 
     attr_writer :use_seed_loader
     def use_seed_loader?
-      @use_seed_loader.nil? ? true : @use_seed_loader
+      @use_seed_loader.nil? || @use_seed_loader
     end
+
+    attr_accessor :logger
   end
 end

data/lib/seed_builder/loader.rb

@@ -1,50 +1,188 @@
 module SeedBuilder
   class Loader
+    SEED_NAME = /\A[A-Za-z0-9_]+\z/
+    private_constant :SEED_NAME
+
     def load_seed
-      initial_logger = Rails.logger
+      default_path = SeedBuilder.config.default_seeds_full_path
+      base_path = SeedBuilder.config.seeds_full_path
+      load_default = SeedBuilder.config.load_default_seeds? && File.file?(default_path.to_s)
+      if SeedBuilder.config.load_seeds? && !File.directory?(base_path.to_s)
+        warn_seed("Seed directory #{base_path} does not exist")
+      end
+      load_directory = SeedBuilder.config.load_seeds? && File.directory?(base_path.to_s)
+      return unless load_default || load_directory
+
+      prepare_active_record
+      load_default_seed(default_path) if load_default
+      load_directory_seeds(base_path) if load_directory
+    end
+
+    def load_seed_file(seed_name)
+      base_path = SeedBuilder.config.seeds_full_path
+      unless seed_name.is_a?(String) && SEED_NAME.match?(seed_name)
+        warn_seed("Seed name '#{seed_name}' is invalid")
+        return false
+      end
+
+      unless File.directory?(base_path.to_s)
+        warn_seed("Seed directory #{base_path} does not exist")
+        return false
+      end
+
+      result = locate_seed_file(base_path, seed_name)
+      if result.nil?
+        warn_seed("Seed file '#{seed_name}' not found in #{base_path}")
+        return false
+      elsif result.is_a?(Array) && result.first == :ambiguous
+        matches = result.last
+        logger.tagged("seed") do
+          logger.warn "Multiple seed files match '#{seed_name}':"
+          matches.each do |file|
+            logger.warn "  - #{File.basename(file, ".*")}"
+          end
+          logger.warn "Please be more specific using the full name with timestamp (e.g., 20241206200111_create_users)"
+        end
+        return false
+      end
+
+      seed_file = result
+      seed_path = File.basename(seed_file, ".*")
+      timestamp, klass_name = split_seed_basename(seed_path)
+      if klass_name.blank?
+        warn_seed("Invalid seed file format: #{seed_path}. Expected format: TIMESTAMP_CLASS_NAME.rb")
+        return false
+      end
+
+      prepare_active_record
+      load seed_file
+      execute_seed_class(klass_name, timestamp, seed_name)
+      true
+    end
+
+    private
+
+    def logger
+      SeedBuilder.logger
+    end
+
+    def warn_seed(message)
+      logger.tagged("seed") do
+        logger.warn(message)
+      end
+    end
+
+    def load_default_seed(default_path)
+      started_at = Time.current
+      logger.tagged("seed") do
+        logger.info "== #{SeedBuilder.config.default_seeds_path}: seeding"
+      end
+      load default_path
+      logger.tagged("seed") do
+        logger.info "== #{SeedBuilder.config.default_seeds_path}: seeded (#{(Time.current - started_at).round(4)}s)"
+      end
+    end
 
-      Rails.logger = Logger.new($stdout)
-      Rails.logger.level = Logger::INFO
+    def load_directory_seeds(base_path)
+      seed_basenames(base_path).each do |seed_path|
+        full_path = File.join(base_path, "#{seed_path}.rb")
+        unless inside_directory?(base_path, full_path)
+          warn_seed("Seed file #{seed_path} was not loaded from #{base_path}")
+          next
+        end
 
+        load full_path
+        timestamp, klass_name = split_seed_basename(seed_path)
+        next if klass_name.blank?
+
+        execute_seed_class(klass_name, timestamp)
+      end
+    end
+
+    def prepare_active_record
       ActiveRecord::Base.connection.schema_cache.clear!
       ActiveRecord::Base.descendants.each(&:reset_column_information)
+    end
 
-      default_seeds_rb = SeedBuilder.config.default_seeds_full_path
-      if File.exist?(default_seeds_rb) && SeedBuilder.config.load_default_seeds?
-        started_at = Time.current
-        puts "== #{SeedBuilder.config.default_seeds_path}: seeding"
-        require default_seeds_rb
-        puts "== #{SeedBuilder.config.default_seeds_path}: seeded (#{(Time.current - started_at).round(4)}s)"
+    def execute_seed_class(klass_name, timestamp, seed_name = nil)
+      klass = klass_name.camelize.constantize
+      klass_name_display = klass.name
+      logger.tagged("seed") do
+        logger.info "== #{timestamp} #{klass_name_display}: seeding"
+      end
+      started_at = Time.current
+      seed_instance = klass.new
+      if seed_instance.respond_to?(:change)
+        seed_instance.change
+      else
+        raise "Seed #{klass_name_display} does not respond to :change"
       end
+      logger.tagged("seed") do
+        logger.info "== #{timestamp} #{klass_name_display}: seeded (#{(Time.current - started_at).round(4)}s)"
+      end
+    rescue ActiveRecord::RecordInvalid => e
+      klass_name_display = defined?(klass) ? klass.name : (klass_name&.camelize || seed_name || klass_name)
+      logger.tagged("seed") do
+        logger.error "Seeding #{klass_name_display} failed: #{e.record.errors.full_messages}"
+      end
+      raise e
+    rescue => e
+      logger.tagged("seed") do
+        logger.error "Error loading seed: #{e.message}"
+      end
+      raise e
+    end
 
-      base_path = SeedBuilder.config.seeds_full_path
-      if File.exist?(base_path) && SeedBuilder.config.load_seeds?
-        Dir[SeedBuilder.config.seeds_path_glob]
-          .map { |f| File.basename(f, ".*") }
-          .each do |seed_path|
-            require "#{base_path}/#{seed_path}.rb"
-            timestamp, klass_name = seed_path.scan(/^([0-9]+)_(.+)$/).first
-            next if klass_name.blank?
-
-            klass = klass_name.camelize.constantize
-            puts "== #{timestamp} #{klass.name}: seeding"
-            started_at = Time.current
-            seed_instance = klass.new
-            if seed_instance.respond_to?(:change)
-              seed_instance.change
-            else
-              raise "Seed #{klass.name} does not respond to :change"
-            end
-            puts "== #{timestamp} #{klass.name}: seeded (#{(Time.current - started_at).round(4)}s)"
-          rescue ActiveRecord::RecordInvalid => e
-            puts "Seeding #{klass.name} failed: #{e.record.errors.full_messages}"
-            raise e
-          end
+    def locate_seed_file(base_path, seed_name)
+      exact_path = File.join(base_path, "#{seed_name}.rb")
+      if File.file?(exact_path)
+        return inside_directory?(base_path, exact_path) ? exact_path : nil
+      end
+
+      matches = seed_basenames(base_path).filter_map { |basename|
+        next unless basename == seed_name || basename.end_with?("_#{seed_name}") || basename.start_with?("#{seed_name}_")
+
+        path = File.join(base_path, "#{basename}.rb")
+        path if inside_directory?(base_path, path)
+      }
+
+      case matches.length
+      when 0
+        nil
+      when 1
+        matches.first
       else
-        puts "Seed directory #{base_path} does not exist"
+        [:ambiguous, matches]
       end
+    end
+
+    def seed_basenames(base_path)
+      Dir.children(base_path.to_s).filter_map { |entry|
+        next if entry.start_with?(".")
+        next unless entry.end_with?(".rb")
+
+        File.basename(entry, ".rb")
+      }.sort_by { |name| seed_sort_key(name) }
+    end
+
+    def seed_sort_key(name)
+      match = name.match(/\A([0-9]+)_/)
+      match ? [0, match[1].to_i, name] : [1, 0, name]
+    end
+
+    def split_seed_basename(seed_path)
+      match = seed_path.match(/\A([0-9]+)_(.+)\z/)
+      return [nil, nil] unless match
+
+      [match[1], match[2]]
+    end
 
-      Rails.logger = initial_logger
+    def inside_directory?(base_path, file_path)
+      root = File.realpath(base_path.to_s)
+      resolved = File.realpath(file_path)
+      resolved.start_with?(root + File::SEPARATOR)
+    rescue Errno::ENOENT
+      false
     end
   end
 end

data/lib/seed_builder/railtie.rb

@@ -0,0 +1,15 @@
+module SeedBuilder
+  class Railtie < ::Rails::Railtie
+    config.to_prepare do
+      if SeedBuilder.config.use_seed_loader?
+        # Patch Rails.application.load_seed to use our custom loader
+        Rails.application.class.class_eval do
+          define_method(:load_seed) do
+            loader = SeedBuilder::Loader.new
+            loader.load_seed
+          end
+        end
+      end
+    end
+  end
+end

data/lib/seed_builder.rb

@@ -1,8 +1,9 @@
+require "active_support/tagged_logging"
 require "seed_builder/config"
 require "seed_builder/loader"
 
 module SeedBuilder
-  VERSION = "1.2.1".freeze
+  VERSION = "1.3.1".freeze
 
   module_function
 
@@ -13,6 +14,25 @@ module SeedBuilder
   def configure
     yield config
   end
+
+  def logger
+    # Use configured logger if set
+    base_logger = if config.logger
+      config.logger
+    elsif defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+      Rails.logger
+    else
+      Logger.new($stdout)
+    end
+
+    # If the logger already supports tagging (e.g., Rails.logger is already TaggedLogging),
+    # use it directly to avoid double-wrapping and ensure tags propagate properly
+    if base_logger.respond_to?(:tagged)
+      base_logger
+    else
+      ActiveSupport::TaggedLogging.new(base_logger)
+    end
+  end
 end
 
-require "rails_config"
+require "seed_builder/railtie" if defined?(Rails::Railtie)

data/lib/tasks/seed.rake

@@ -0,0 +1,22 @@
+namespace :seed do
+  desc "Run a specific seed file by name"
+  task :run, [:seed_name] => :environment do |_task, args|
+    if args[:seed_name].blank?
+      puts "Usage: bin/rails seed:run[SEED_NAME]"
+      puts ""
+      puts "Run a specific seed file by name."
+      puts ""
+      puts "Examples:"
+      puts "  bin/rails seed:run[create_users]"
+      puts "  bin/rails seed:run[20241206200111_create_users]"
+      puts "  bin/rails seed:run[20241206200111]"
+      puts ""
+      puts "Note: If multiple seed files match the name, use the full name with"
+      puts "      timestamp to avoid ambiguity (e.g., 20241206200111_create_users)."
+      exit 1
+    end
+
+    loader = SeedBuilder::Loader.new
+    exit 1 unless loader.load_seed_file(args[:seed_name])
+  end
+end