seed_dump 3.3.1 → 3.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3ef68666d03715b3fb9f373025af97819527ce9f2cf2c68cca2237b9453901a
-  data.tar.gz: 444459b826e138ab26977b25d0b94439f42a3debbfbab922a40bb88a64a6e1d3
+  metadata.gz: e51de5d37ae0d9f14a4c6126a53e589e20ab504e6fb79bff59e61e4950bb4633
+  data.tar.gz: edfad4053c8dafa40d45de0a6b01fbf6dd97645945015d68887be0ee38ebb640
 SHA512:
-  metadata.gz: 526f868754d161d41ee9771502b35c1aa6658b695a7f7a8eca695b2515da5926f2fa02f6c1aff478cb5f5d07e0d1842ed1221d0900df4fe7f50267dace0de0a8
-  data.tar.gz: 0b6629fb2b2baea086bb16d76b36b02d659f77f1330b351d7a311b8658e4ad993f14121fd04267ba4d3eadc7b301c04092b776276317c74068ddb015bc83380e
+  metadata.gz: 4fa4f77d53981389543d97e2295cc0945effdc5360fdfce1d10beedfda43ca6116763b7f05105ba928d45e903bb568f78ae71ace57a5dbab9fcf3d23b919d590
+  data.tar.gz: 3cec4ce1c103182cb46f1c53e126c1563911efb7253bd783eb9d623c07d7efc9323072a51de8bd006002ebc347a163ce78a464d4a0a8660dc20781c8b4e3dd40

data/README.md

@@ -1,7 +1,6 @@
-Seed Dump
-========
+# Seed Dump
 
-Seed Dump is a Rails 4 and 5 plugin that adds a rake task named `db:seed:dump`.
+Seed Dump is a Rails plugin (compatible with **Rails 4 through 8+**) that adds a rake task named `db:seed:dump`.
 
 It allows you to create seed data files from the existing data in your database.
 
@@ -9,8 +8,7 @@ You can also use Seed Dump from the Rails console. See below for usage examples.
 
 Note: if you want to use Seed Dump with Rails 3 or earlier, use [version 0.5.3](http://rubygems.org/gems/seed_dump/versions/0.5.3).
 
-Installation
-------------
+## Installation
 
 Add it to your Gemfile with:
 ```ruby
@@ -20,8 +18,7 @@ Or install it by hand:
 ```sh
 $ gem install seed_dump
 ```
-Examples
---------
+## Examples
 
 ### Rake task
 
@@ -98,34 +95,73 @@ irb(main):004:0> SeedDump.dump(User, exclude: [:name, :age])
 
 Options are specified as a Hash for the second argument.
 
-In the console, any relation of ActiveRecord rows can be dumped (not individual objects though)
+In the console, any relation of ActiveRecord rows can be dumped (not individual objects though):
 ```ruby
-irb(main):001:0> puts SeedDump.dump(User.where(is_admin: false))
+irb(main):005:0> puts SeedDump.dump(User.where(is_admin: false))
 User.create!([
   { password: "123456", username: "test_1", is_admin: false },
   { password: "234567", username: "test_2", is_admin: false }
 ])
 ```
 
-Options
--------
+## Options
 
 Options are common to both the Rake task and the console, except where noted.
 
 `append`: If set to `true`, append the data to the file instead of overwriting it. Default: `false`.
 
-`batch_size`: Controls the number of records that are written to file at a given time. Default: 1000. If you're running out of memory when dumping, try decreasing this. If things are dumping too slow, trying increasing this.
+`batch_size`: Controls the number of records that are processed and written at a given time. Default: 1000. If you're running out of memory when dumping, try decreasing this. If things are dumping too slow, trying increasing this.
 
-`exclude`: Attributes to be excluded from the dump. Pass a comma-separated list to the Rake task (i.e. `name,age`) and an array on the console (i.e. `[:name, :age]`). Default: `[:id, :created_at, :updated_at]`.
+`exclude`: Attributes to be excluded from the dump. Pass a comma-separated list to the Rake task (e.g., `EXCLUDE=name,age`) and an array of symbols on the console (e.g., `exclude: [:name, :age]`). Default: `[:id, :created_at, :updated_at, :created_on, :updated_on]`.
 
-`file`: Write to the specified output file. The Rake task default is `db/seeds.rb`. The console returns the dump as a string by default.
+`file`: Write to the specified output file. The Rake task default is `db/seeds.rb`. The console returns the dump as a string by default if this option is omitted.
 
-`import`: If `true`, output will be in the format needed by the [activerecord-import](https://github.com/zdennis/activerecord-import) gem, rather than the default format. Default: `false`.
+`group_sti_by_class`: If `true`, Single Table Inheritance (STI) records are grouped by their actual class (e.g., `Dog`, `Cat`) instead of the base class (e.g., `Animal`). This is necessary when STI subclasses have different enum definitions or other class-specific attributes that would be lost if dumped via the base class. Default: `false`. Example: `rake db:seed:dump GROUP_STI_BY_CLASS=true` or `SeedDump.dump(Animal, group_sti_by_class: true)`. See the STI Handling section below for more details.
 
-`limit`: Dump no more than this amount of data. Default: no limit. Rake task only. In the console just pass in an ActiveRecord::Relation with the appropriate limit (e.g. `SeedDump.dump(User.limit(5))`).
+`header`: If `true`, adds a comment header to the output file showing the seed_dump command and options used. If a string, uses that string as the header comment. Default: `false`. **Rake task only.** Example: `rake db:seed:dump HEADER=true` or `HEADER="Generated by seed_dump"`.
 
-`conditions`: Dump only specific records. In the console just pass in an ActiveRecord::Relation with the appropriate conditions (e.g. `SeedDump.dump(User.where(state: :active))`).
+`import`: If `true`, output will be in the format needed by the [activerecord-import](https://github.com/zdennis/activerecord-import) gem, rather than the default format. You can also pass a Hash of options which will be passed through to the `import` call (e.g., `IMPORT='{ "validate": false }'` for Rake, or `import: { validate: false }` for console). Default: `false`.
 
-`model[s]`: Restrict the dump to the specified comma-separated list of models. Default: all models. If you are using a Rails engine you can dump a specific model by passing "EngineName::ModelName". Rake task only. Example: `rake db:seed:dump MODELS="User, Position, Function"`
+`include_all`: If set to `true`, include all columns in the dump (including `id`, `created_at`, and `updated_at`). Equivalent to `EXCLUDE=""`. Default: `false`. **Rake task only.** Example: `rake db:seed:dump INCLUDE_ALL=true`
 
-`models_exclude`: Exclude the specified comma-separated list of models from the dump. Default: no models excluded. Rake task only. Example: `rake db:seed:dump MODELS_EXCLUDE="User"`
+`insert_all`: If `true`, output will use Rails 6+ [`insert_all`](https://api.rubyonrails.org/classes/ActiveRecord/Persistence/ClassMethods.html#method-i-insert_all) for faster bulk inserts that bypass validations and callbacks. Default: `false`. Example: `rake db:seed:dump INSERT_ALL=true` or `SeedDump.dump(User, insert_all: true)`.
+
+`limit`: Dump no more than this amount of data *per model*. Default: no limit. **Rake task only.** In the console, just pass in an ActiveRecord::Relation with the appropriate limit (e.g., `SeedDump.dump(User.limit(5))`).
+
+`model_limits`: Set different limits for specific models. Format: `Model1:limit1,Model2:limit2`. Use `0` to mean "no limit" for a specific model. This is useful when `LIMIT` would break foreign key relationships. **Rake task only.** Example: `rake db:seed:dump LIMIT=10 MODEL_LIMITS="Teacher:0,Student:50"` dumps all Teachers, 50 Students, and 10 of everything else.
+
+`model[s]`: Restrict the dump to the specified comma-separated list of models. Default: all models that have data. If you are using a Rails engine you can dump a specific model by passing "EngineName::ModelName". **Rake task only.** Example: `rake db:seed:dump MODELS="User, Position, Function"`
+
+`models_exclude`: Exclude the specified comma-separated list of models from the dump. Default: no models excluded. **Rake task only.** Example: `rake db:seed:dump MODELS_EXCLUDE="User"`
+
+`upsert_all`: If `true`, output will use Rails 6+ [`upsert_all`](https://api.rubyonrails.org/classes/ActiveRecord/Persistence/ClassMethods.html#method-i-upsert_all) which preserves record IDs and handles conflicts by updating existing records. This is useful when you need to maintain foreign key relationships or want idempotent seed files. Automatically includes `id` in the dump. Default: `false`. Example: `rake db:seed:dump UPSERT_ALL=true` or `SeedDump.dump(User, upsert_all: true)`.
+
+## Automatic Behaviors
+
+**Foreign Key Ordering**: Models are automatically dumped in dependency order based on foreign key relationships. This ensures that parent records are created before child records that reference them.
+
+**STI Handling**: Single Table Inheritance (STI) models are automatically deduplicated. By default, only the base class is dumped to avoid duplicate records (e.g., `Animal.create!` for both `Dog` and `Cat` records). However, if your STI subclasses have different enum definitions or other class-specific attributes, use the `group_sti_by_class: true` option to dump each subclass separately (e.g., `Dog.create!` and `Cat.create!`). This ensures that subclass-specific type casting and validations are properly applied when the seed data is loaded.
+
+**HABTM Handling**: Has-and-belongs-to-many join tables are automatically detected and dumped without duplication.
+
+## Usage Outside of Rails
+
+If you're using ActiveRecord outside of Rails (e.g., with [standalone-migrations](https://github.com/thuss/standalone-migrations)), you can set up a custom Rake task:
+
+```ruby
+# In your Rakefile
+$LOAD_PATH.unshift(File.expand_path('app/models', __dir__))
+Dir.glob(File.expand_path('app/models/*.rb', __dir__)).sort.each(&method(:require))
+require 'seed_dump'
+
+namespace :db do
+  namespace :seed do
+    desc "Dump records from the database into db/seeds.rb"
+    task :dump => :environment do
+      SeedDump.dump_using_environment(ENV)
+    end
+  end
+end
+```
+
+This loads your models and creates a `db:seed:dump` task that works like the Rails version.

data/lib/seed_dump/dump_methods/enumeration.rb

@@ -3,9 +3,11 @@ class SeedDump
     module Enumeration
       def active_record_enumeration(records, io, options)
         # If the records don't already have an order,
-        # order them by primary key ascending.
+        # order them by primary key ascending (if the table has a primary key).
         if !records.respond_to?(:arel) || records.arel.orders.blank?
-          records.order("#{records.quoted_table_name}.#{records.quoted_primary_key} ASC")
+          if records.primary_key.present?
+            records = records.order(records.primary_key => :asc)
+          end
         end
 
         num_of_batches, batch_size, last_batch_size = batch_params_from(records, options)
@@ -56,7 +58,13 @@ class SeedDump
       def batch_params_from(records, options)
         batch_size = batch_size_from(records, options)
 
-        count = records.count
+        # Use unscope(:select) to avoid issues with default_scope that selects
+        # specific columns, which would cause COUNT(col1, col2, ...) errors
+        count = if records.respond_to?(:unscope)
+                  records.unscope(:select).count
+                else
+                  records.count
+                end
 
         remainder = count % batch_size