seed-do 3.1.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a144ca5bdde78bd698bd63b5b7ec5d4538e290d494d6d9feaf3b72c2fabc94bd
-  data.tar.gz: 05156a89c384563da57269b0850fc21f89b6d3f87fdb1801d83b5743cc286d22
+  metadata.gz: c5486ba5dbc636b111be4e69d838b7f317b233ea9cf4b516d611fdf5070f0780
+  data.tar.gz: a04c1e585a72163d13184a317aecf059eb4c21f24d9b3e51fd208debf452a574
 SHA512:
-  metadata.gz: 22803ec0568fbfe2d89b20cd65f04c331da02673b901724e7fcd48d22c8b764eff73763c14cd197292e9408f7345fe562a4c1ee5b329f3c8e926b7a25413e166
-  data.tar.gz: '006481304627db4be5b6eb2ebba80c043078b78c1b4e815a9323398a7aa9f7b395ca3971cb0069f942413a957637f8cf839f71c479ebb9feaa8cf6f7b915ba83'
+  metadata.gz: a5d0cbf12b3790a33f0c362967c4a7b20a85ef7cdb3e9a0c15b47111d0a4fab0ae5912728c1fbab4be32697669f4ed672d221badc00ea5abca06999117e3a4fb
+  data.tar.gz: 0011f72cf7c27fcfef5d8dad96ca74525582eaf9ddc01e66dd0b1b575e255d28c72c49db6b81f0523704991ab12545d7a4ebfc75c83fe46ef8ede8a71448d423

data/README.md

@@ -142,6 +142,30 @@ Seed files can be run automatically using `rake db:seed_do`. There are two optio
 
 You can also do a similar thing in your code by calling `SeedDo.seed(fixture_paths, filter)`.
 
+## Bulk upsert
+
+If you load a large amount of seed data, you can enable bulk upsert mode:
+
+```ruby
+SeedDo.seed(bulk: true)
+```
+
+In bulk mode, SeedDo buffers seed data for each file and writes it with `upsert_all`, which can significantly reduce the number of queries.
+
+You can also control the batch size per `upsert_all` call. The default is `1000`.
+
+```ruby
+SeedDo.seed(bulk: { batch_size: 100 })
+```
+
+### Requirements and caveats
+
+- Bulk mode relies on Rails `upsert_all`
+- The seed constraints are passed to `unique_by`, so the related columns must have a unique index
+- Bulk mode is supported only on databases that support conflict targets, such as PostgreSQL and SQLite
+- Bulk mode is not available on MySQL
+- `SeedDo.seed` and `SeedDo.seed(bulk: true)` may not always produce the same record order, so verify the behavior carefully before enabling it in an existing production environment
+
 ## Disable output
 
 To disable output from Seed Do, set `SeedDo.quiet = true`.
@@ -200,6 +224,22 @@ DB=postgresql bundle exec rspec
 
 The connection paramaters for each of these are specified in spec/connections/, which you can edit if necessary (for example to change the username/password).
 
+### Dev Container
+
+This repository includes a Dev Container setup for running the test suite locally with Ruby, SQLite, MySQL, and PostgreSQL ready to use.
+
+1. Open the repository in a Dev Container.
+2. Wait for `bundle install` to finish.
+3. Run the specs you want:
+
+```
+bundle exec rspec
+DB=mysql2 bundle exec rspec
+DB=postgresql bundle exec rspec
+```
+
+The Dev Container config also sets `MYSQL_HOST=mysql` and `POSTGRES_HOST=postgres` automatically, so the database-backed specs work without editing local machine settings.
+
 ## Original Author
 
 [Michael Bleigh](http://www.mbleigh.com/) is the original author

data/lib/seed-do/active_record_extension.rb

@@ -29,7 +29,7 @@ module SeedDo
     #       { :x => 5, :y => 9,  :name => "Office" }
     #     )
     def seed(*args, &block)
-      SeedDo::Seeder.new(self, *parse_seed_do_args(args, block)).seed
+      SeedDo.current_seeder.seed(self, *parse_seed_do_args(args, block))
     end
 
     # Has the same syntax as {#seed}, but if a record already exists with the same values for
@@ -40,26 +40,25 @@ module SeedDo
     #   Person.seed(:id, :id => 1, :name => "Bob") # => Name changed
     #   Person.seed_once(:id, :id => 1, :name => "Harry") # => Name *not* changed
     def seed_once(*args, &block)
-      constraints, data = parse_seed_do_args(args, block)
-      SeedDo::Seeder.new(self, constraints, data, :insert_only => true).seed
+      SeedDo.current_seeder.seed_once(self, *parse_seed_do_args(args, block))
     end
 
     private
 
-      def parse_seed_do_args(args, block)
-        if block.nil?
-          if args.last.is_a?(Array)
-            # Last arg is an array of data, so assume the rest of the args are constraints
-            data = args.pop
-            [args, data]
-          else
-            # Partition the args, assuming the first hash is the start of the data
-            args.partition { |arg| !arg.is_a?(Hash) }
-          end
+    def parse_seed_do_args(args, block)
+      if block.nil?
+        if args.last.is_a?(Array)
+          # Last arg is an array of data, so assume the rest of the args are constraints
+          data = args.pop
+          [args, data]
         else
-          # We have a block, so assume the args are all constraints
-          [args, [SeedDo::BlockHash.new(block).to_hash]]
+          # Partition the args, assuming the first hash is the start of the data
+          args.partition { |arg| !arg.is_a?(Hash) }
         end
+      else
+        # We have a block, so assume the args are all constraints
+        [args, [SeedDo::BlockHash.new(block).to_hash]]
       end
+    end
   end
 end

data/lib/seed-do/block_hash.rb

@@ -12,7 +12,7 @@ module SeedDo
 
     def method_missing(method_name, *args, &block)
       if method_name.to_s =~ /^(.*)=$/ && args.length == 1 && block.nil?
-        @hash[$1] = args.first
+        @hash[::Regexp.last_match(1)] = args.first
       else
         super
       end

data/lib/seed-do/bulk_seeder.rb

@@ -0,0 +1,66 @@
+module SeedDo
+  # Buffers seeds during a file run and flushes them in bulk.
+  class BulkSeeder
+    attr_reader :buffer
+
+    def initialize(batch_size: 1000)
+      @batch_size = batch_size
+      @buffer = nil
+
+      validate_support!
+    end
+
+    def seed(model, constraints, data)
+      puts " - #{model} #{data.inspect}" unless SeedDo.quiet
+      buffer[:seed] << { model: model, constraints: constraints, data: data }
+    end
+
+    def seed_once(model, constraints, data)
+      puts " - #{model} #{data.inspect}" unless SeedDo.quiet
+      buffer[:seed_once] << { model: model, constraints: constraints, data: data }
+    end
+
+    def with_seed_file
+      @buffer = { seed: [], seed_once: [] }
+      yield
+      process_buffer
+    ensure
+      @buffer = nil
+    end
+
+    private
+
+    def validate_support!
+      return if ActiveRecord::Base.connection.supports_insert_conflict_target?
+
+      raise ArgumentError,
+            "Bulk mode is not supported for #{ActiveRecord::Base.connection.adapter_name}. " \
+            'The database does not support upsert operations with conflict targets. ' \
+            'Please use SeedDo.seed without the bulk option.'
+    end
+
+    def process_buffer
+      return unless buffer
+
+      buffer.each do |type, operations|
+        next if operations.empty?
+
+        operations.chunk { |operation| [operation[:model], operation[:constraints]] }
+                  .each do |(model, constraints), chunk|
+          flush_chunk(model, constraints, type, chunk)
+        end
+      end
+    end
+
+    def flush_chunk(model, constraints, type, chunk)
+      all_data = chunk.flat_map { |operation| operation[:data] }
+
+      options = { unique_by: constraints }
+      options[:on_duplicate] = :skip if type == :seed_once
+
+      all_data.each_slice(@batch_size) do |batch|
+        model.upsert_all(batch, **options)
+      end
+    end
+  end
+end

data/lib/seed-do/capistrano.rb

@@ -1,7 +1,7 @@
 Capistrano::Configuration.instance.load do
   namespace :db do
-    desc "Load seed data into database"
-    task :seed_do, :roles => :db, :only => { :primary => true } do
+    desc 'Load seed data into database'
+    task :seed_do, roles: :db, only: { primary: true } do
       run "cd #{release_path} && bundle exec rake RAILS_ENV=#{rails_env} db:seed_do"
     end
   end

data/lib/seed-do/capistrano3.rb

@@ -1 +1 @@
-load File.expand_path('../../tasks/seed_do_capistrano3.rake', __FILE__)
+load File.expand_path('../tasks/seed_do_capistrano3.rake', __dir__)

data/lib/seed-do/railtie.rb

@@ -1,7 +1,7 @@
 module SeedDo
   class Railtie < Rails::Railtie
     rake_tasks do
-      load "tasks/seed_do.rake"
+      load 'tasks/seed_do.rake'
     end
 
     initializer 'seed_do.set_fixture_paths' do

data/lib/seed-do/runner.rb

@@ -3,9 +3,7 @@ require 'active_support/core_ext/array/wrap'
 
 module SeedDo
   # Runs seed files.
-  #
-  # It is not recommended to use this class directly. Instead, use {SeedDo.seed SeedDo.seed}, which creates
-  # an instead of {Runner} and calls {#run #run}.
+  # It is not recommended to use this class directly. Instead, use {SeedDo.seed SeedDo.seed}, which creates an instead of {Runner} and calls {#run #run}.
   #
   # @see SeedDo.seed SeedDo.seed
   class Runner
@@ -13,61 +11,80 @@ module SeedDo
     #   `SeedDo.fixture_paths` if {nil}. If the argument is not an array, it will be wrapped by one.
     # @param [Regexp] filter If given, only seed files with a file name matching this pattern will
     #   be used
-    def initialize(fixture_paths = nil, filter = nil)
+    # @param [Boolean, Hash] bulk If true, use upsert_all to insert/update records in bulk.
+    #   If a hash, can include :batch_size (default: 1000) to control the number of records
+    #   per upsert_all call.
+    def initialize(fixture_paths = nil, filter = nil, bulk: false)
       @fixture_paths = Array.wrap(fixture_paths || SeedDo.fixture_paths)
       @filter        = filter
+      @seeder        = build_seeder(bulk)
     end
 
     # Run the seed files.
     def run
+      SeedDo.current_seeder = @seeder
       puts "\n== Filtering seed files against regexp: #{@filter.inspect}" if @filter && !SeedDo.quiet
 
-      filenames.each do |filename|
-        run_file(filename)
-      end
+      filenames.each { |filename| run_file(filename) }
+    ensure
+      SeedDo.current_seeder = nil
+    end
+
+    def seed(model, constraints, data)
+      @seeder.seed(model, constraints, data)
+    end
+
+    def seed_once(model, constraints, data)
+      @seeder.seed_once(model, constraints, data)
     end
 
     private
 
-      def run_file(filename)
-        puts "\n== Seed from #{filename}" unless SeedDo.quiet
+    def run_file(filename)
+      puts "\n== Seed from #{filename}" unless SeedDo.quiet
+
+      ActiveRecord::Base.transaction do
+        @seeder.with_seed_file { _run_file(filename) }
+      end
+    end
+
+    def build_seeder(bulk)
+      return SeedDo::BulkSeeder.new(batch_size: bulk.fetch(:batch_size, 1000)) if bulk.is_a?(Hash)
 
-        ActiveRecord::Base.transaction do
-          open(filename) do |file|
+      bulk ? SeedDo::BulkSeeder.new : SeedDo::Seeder.new
+    end
+
+    def _run_file(filename)
+      open(filename) do |file|
+        chunked_ruby = +''
+        file.each_line do |line|
+          if line == "# BREAK EVAL\n"
+            eval(chunked_ruby)
             chunked_ruby = +''
-            file.each_line do |line|
-              if line == "# BREAK EVAL\n"
-                eval(chunked_ruby)
-                chunked_ruby = +''
-              else
-                chunked_ruby << line
-              end
-            end
-            eval(chunked_ruby) unless chunked_ruby == ''
+          else
+            chunked_ruby << line
           end
         end
+        eval(chunked_ruby) unless chunked_ruby == ''
       end
+    end
 
-      def open(filename)
-        if filename[-3..-1] == '.gz'
-          Zlib::GzipReader.open(filename) do |file|
-            yield file
-          end
-        else
-          File.open(filename) do |file|
-            yield file
-          end
-        end
+    def open(filename, &)
+      if filename[-3..-1] == '.gz'
+        Zlib::GzipReader.open(filename, &)
+      else
+        File.open(filename, &)
       end
+    end
 
-      def filenames
-        filenames = []
-        @fixture_paths.each do |path|
-          filenames += (Dir[File.join(path, '*.rb')] + Dir[File.join(path, '*.rb.gz')]).sort
-        end
-        filenames.uniq!
-        filenames = filenames.find_all { |filename| filename =~ @filter } if @filter
-        filenames
+    def filenames
+      filenames = []
+      @fixture_paths.each do |path|
+        filenames += (Dir[File.join(path, '*.rb')] + Dir[File.join(path, '*.rb.gz')]).sort
       end
+      filenames.uniq!
+      filenames = filenames.find_all { |filename| filename =~ @filter } if @filter
+      filenames
+    end
   end
 end

data/lib/seed-do/seeder.rb

@@ -8,30 +8,31 @@ module SeedDo
   #
   # @see ActiveRecordExtension
   class Seeder
-    # @param [ActiveRecord::Base] model_class The model to be seeded
-    # @param [Array<Symbol>] constraints A list of attributes which identify a particular seed. If
-    #   a record with these attributes already exists then it will be updated rather than created.
-    # @param [Array<Hash>] data Each item in this array is a hash containing attributes for a
-    #   particular record.
-    # @param [Hash] options
-    # @option options [Boolean] :quiet (SeedDo.quiet) If true, output will be silenced
-    # @option options [Boolean] :insert_only (false) If true then existing records which match the
-    #   constraints will not be updated, even if the seed data has changed
-    def initialize(model_class, constraints, data, options = {})
+    def seed(model_class, constraints, data)
+      seed_records(model_class, constraints, data)
+    end
+
+    def seed_once(model_class, constraints, data)
+      seed_records(model_class, constraints, data, insert_only: true)
+    end
+
+    def with_seed_file
+      yield
+    end
+
+    private
+
+    # Insert/update the records as appropriate. Validation is skipped while saving.
+    # @return [Array<ActiveRecord::Base>] The records which have been seeded
+    def seed_records(model_class, constraints, data, options = {})
       @model_class = model_class
       @constraints = constraints.to_a.empty? ? [:id] : constraints
       @data        = data.to_a || []
       @options     = options.symbolize_keys
 
-      @options[:quiet] ||= SeedDo.quiet
-
       validate_constraints!
       validate_data!
-    end
 
-    # Insert/update the records as appropriate. Validation is skipped while saving.
-    # @return [Array<ActiveRecord::Base>] The records which have been seeded
-    def seed
       records = @model_class.transaction do
         @data.map { |record_data| seed_record(record_data.symbolize_keys) }
       end
@@ -39,64 +40,61 @@ module SeedDo
       records
     end
 
-    private
+    def validate_constraints!
+      unknown_columns = @constraints.map(&:to_s) - @model_class.column_names
+      return if unknown_columns.empty?
 
-      def validate_constraints!
-        unknown_columns = @constraints.map(&:to_s) - @model_class.column_names
-        unless unknown_columns.empty?
-          raise(ArgumentError,
+      raise(ArgumentError,
             "Your seed constraints contained unknown columns: #{column_list(unknown_columns)}. " +
             "Valid columns are: #{column_list(@model_class.column_names)}.")
-        end
-      end
+    end
 
-      def validate_data!
-        raise ArgumentError, "Seed data missing" if @data.empty?
-      end
+    def validate_data!
+      raise ArgumentError, 'Seed data missing' if @data.empty?
+    end
 
-      def column_list(columns)
-        '`' + columns.join("`, `") + '`'
-      end
+    def column_list(columns)
+      '`' + columns.join('`, `') + '`'
+    end
 
-      def seed_record(data)
-        record = find_or_initialize_record(data)
-        return if @options[:insert_only] && !record.new_record?
+    def seed_record(data)
+      record = find_or_initialize_record(data)
+      return if @options[:insert_only] && !record.new_record?
 
-        puts " - #{@model_class} #{data.inspect}" unless @options[:quiet]
+      puts " - #{@model_class} #{data.inspect}" unless SeedDo.quiet
 
-        record.assign_attributes(data)
-        record.save(:validate => false) || raise(ActiveRecord::RecordNotSaved, 'Record not saved!')
-        record
-      end
+      record.assign_attributes(data)
+      record.save(validate: false) || raise(ActiveRecord::RecordNotSaved, 'Record not saved!')
+      record
+    end
 
-      def find_or_initialize_record(data)
-        @model_class.where(constraint_conditions(data)).take ||
+    def find_or_initialize_record(data)
+      @model_class.where(constraint_conditions(data)).take ||
         @model_class.new
-      end
+    end
 
-      def constraint_conditions(data)
-        Hash[@constraints.map { |c| [c, data[c.to_sym]] }]
-      end
+    def constraint_conditions(data)
+      @constraints.to_h { |c| [c, data[c.to_sym]] }
+    end
 
-      def update_id_sequence
-        if @model_class.connection.adapter_name == "PostgreSQL" or @model_class.connection.adapter_name == "PostGIS"
-          return if @model_class.primary_key.nil? || @model_class.sequence_name.nil?
+    def update_id_sequence
+      return unless %w[PostgreSQL PostGIS].include?(@model_class.connection.adapter_name)
+      return if @model_class.primary_key.nil? || @model_class.sequence_name.nil?
 
-          quoted_id       = @model_class.connection.quote_column_name(@model_class.primary_key)
-          sequence = @model_class.sequence_name
+      quoted_id = @model_class.connection.quote_column_name(@model_class.primary_key)
+      sequence = @model_class.sequence_name
 
-          if @model_class.connection.postgresql_version >= 100000
-            sql =<<-EOS
+      if @model_class.connection.postgresql_version >= 100_000
+        sql = <<-EOS
               SELECT setval('#{sequence}', (SELECT GREATEST(MAX(#{quoted_id})+(SELECT seqincrement FROM pg_sequence WHERE seqrelid = '#{sequence}'::regclass), (SELECT seqmin FROM pg_sequence WHERE seqrelid = '#{sequence}'::regclass)) FROM #{@model_class.quoted_table_name}), false)
-            EOS
-          else
-            sql =<<-EOS
+        EOS
+      else
+        sql = <<-EOS
               SELECT setval('#{sequence}', (SELECT GREATEST(MAX(#{quoted_id})+(SELECT increment_by FROM #{sequence}), (SELECT min_value FROM #{sequence})) FROM #{@model_class.quoted_table_name}), false)
-            EOS
-          end
-
-          @model_class.connection.execute sql
-        end
+        EOS
       end
+
+      @model_class.connection.execute sql
+    end
   end
 end

data/lib/seed-do/version.rb

@@ -1,3 +1,3 @@
 module SeedDo
-  VERSION = '3.1.0'
+  VERSION = '4.0.0'
 end

data/lib/seed-do/writer.rb

@@ -18,9 +18,9 @@ module SeedDo
   class Writer
     cattr_accessor :default_options
     @@default_options = {
-      :chunk_size  => 100,
-      :constraints => [:id],
-      :seed_type   => :seed
+      chunk_size: 100,
+      constraints: [:id],
+      seed_type: :seed
     }
 
     # @param [Hash] options
@@ -33,13 +33,13 @@ module SeedDo
     # @option options [Array<Symbol>] :constraints ([:id]) The constraining attributes for the seeds
     def initialize(options = {})
       @options = self.class.default_options.merge(options)
-      raise ArgumentError, "missing option :class_name" unless @options[:class_name]
+      raise ArgumentError, 'missing option :class_name' unless @options[:class_name]
     end
 
     # Creates a new instance of {Writer} with the `options`, and then calls {#write} with the
     # `io_or_filename` and `block`
-    def self.write(io_or_filename, options = {}, &block)
-      new(options).write(io_or_filename, &block)
+    def self.write(io_or_filename, options = {}, &)
+      new(options).write(io_or_filename, &)
     end
 
     # Writes the necessary headers and footers, and yields to a block within which the actual
@@ -51,7 +51,7 @@ module SeedDo
     #   closed automatically.)
     # @yield [self] make calls to `#<<` within the block
     def write(io_or_filename, &block)
-      raise ArgumentError, "missing block" unless block_given?
+      raise ArgumentError, 'missing block' unless block_given?
 
       if io_or_filename.respond_to?(:write)
         write_to_io(io_or_filename, &block)
@@ -65,7 +65,7 @@ module SeedDo
     # Add a seed. Must be called within a block passed to {#write}.
     # @param [Hash] seed The attributes for the seed
     def <<(seed)
-      raise "You must add seeds inside a SeedDo::Writer#write block" unless @io
+      raise 'You must add seeds inside a SeedDo::Writer#write block' unless @io
 
       buffer = +''
 
@@ -76,57 +76,59 @@ module SeedDo
       end
 
       buffer << ",\n"
-      buffer << '  ' + seed.inspect
+      buffer << ('  ' + seed.inspect)
 
       @io.write(buffer)
 
       @count += 1
     end
-    alias_method :add, :<<
+    alias add <<
 
     private
 
-      def write_to_io(io)
-        @io, @count = io, 0
-        @io.write(file_header)
-        @io.write(seed_header)
-        yield(self)
-        @io.write(seed_footer)
-        @io.write(file_footer)
-      ensure
-        @io, @count = nil, nil
-      end
+    def write_to_io(io)
+      @io = io
+      @count = 0
+      @io.write(file_header)
+      @io.write(seed_header)
+      yield(self)
+      @io.write(seed_footer)
+      @io.write(file_footer)
+    ensure
+      @io = nil
+      @count = nil
+    end
 
-      def file_header
-        <<-END
-# DO NOT MODIFY THIS FILE, it was auto-generated.
-#
-# Date: #{Time.now}
-# Seeding #{@options[:class_name]}
-# Written with the command:
-#
-#   #{$0} #{$*.join}
-#
-        END
-      end
+    def file_header
+      <<~END
+        # DO NOT MODIFY THIS FILE, it was auto-generated.
+        #
+        # Date: #{Time.now}
+        # Seeding #{@options[:class_name]}
+        # Written with the command:
+        #
+        #   #{$0} #{$*.join}
+        #
+      END
+    end
 
-      def file_footer
-        <<-END
-# End auto-generated file.
-        END
-      end
+    def file_footer
+      <<~END
+        # End auto-generated file.
+      END
+    end
 
-      def seed_header
-        constraints = @options[:constraints] && @options[:constraints].map(&:inspect).join(', ')
-        "#{@options[:class_name]}.#{@options[:seed_type]}(#{constraints}"
-      end
+    def seed_header
+      constraints = @options[:constraints] && @options[:constraints].map(&:inspect).join(', ')
+      "#{@options[:class_name]}.#{@options[:seed_type]}(#{constraints}"
+    end
 
-      def seed_footer
-        "\n)\n"
-      end
+    def seed_footer
+      "\n)\n"
+    end
 
-      def chunk_this_seed?
-        @count != 0 && (@count % @options[:chunk_size]) == 0
-      end
+    def chunk_this_seed?
+      @count != 0 && (@count % @options[:chunk_size]) == 0
+    end
   end
 end

data/lib/seed-do.rb

@@ -1,32 +1,37 @@
 require 'active_record'
 require 'active_support/core_ext/module/attribute_accessors'
-require 'seed-do/railtie' if defined?(Rails) && Rails.version >= "3"
+require 'seed-do/railtie' if defined?(Rails)
 
 module SeedDo
   autoload :VERSION,               'seed-do/version'
   autoload :Seeder,                'seed-do/seeder'
   autoload :ActiveRecordExtension, 'seed-do/active_record_extension'
   autoload :BlockHash,             'seed-do/block_hash'
+  autoload :BulkSeeder,            'seed-do/bulk_seeder'
   autoload :Runner,                'seed-do/runner'
   autoload :Writer,                'seed-do/writer'
 
-  mattr_accessor :quiet
-
   # Set `SeedDo.quiet = true` to silence all output
-  @@quiet = false
-
-  mattr_accessor :fixture_paths
+  mattr_accessor :quiet, default: false
 
   # Set this to be an array of paths to directories containing your seed files. If used as a Rails
-  # plugin, SeedDo will set to to contain `Rails.root/db/fixtures` and
+  # plugin, SeedDo will set it to contain `Rails.root/db/fixtures` and
   # `Rails.root/db/fixtures/Rails.env`
-  @@fixture_paths = ['db/fixtures']
-
+  mattr_accessor :fixture_paths, default: ['db/fixtures']
   # Load seed data from files
   # @param [Array] fixture_paths The paths to look for seed files in
   # @param [Regexp] filter If given, only filenames matching this expression will be loaded
-  def self.seed(fixture_paths = SeedDo.fixture_paths, filter = nil)
-    Runner.new(fixture_paths, filter).run
+  # @param [Boolean] bulk If true, bulk insert/upsert will be used
+  def self.seed(fixture_paths = SeedDo.fixture_paths, filter = nil, bulk: false)
+    Runner.new(fixture_paths, filter, bulk: bulk).run
+  end
+
+  def self.current_seeder
+    @current_seeder || Seeder.new
+  end
+
+  def self.current_seeder=(seeder)
+    @current_seeder = seeder
   end
 end
 

data/lib/tasks/seed_do.rake

@@ -24,14 +24,10 @@ namespace :db do
       # to load files from RAILS_ROOT/features/fixtures
       rake db:seed_do FIXTURE_PATH=features/fixtures
   EOS
-  task :seed_do => :environment do
-    if ENV["FILTER"]
-      filter = /#{ENV["FILTER"].gsub(/,/, "|")}/
-    end
-
-    if ENV["FIXTURE_PATH"]
-      fixture_paths = [ENV["FIXTURE_PATH"], ENV["FIXTURE_PATH"] + '/' + Rails.env]
-    end
+  task seed_do: :environment do
+    filter = /#{ENV['FILTER'].tr(',', '|')}/ if ENV['FILTER']
+
+    fixture_paths = [ENV['FIXTURE_PATH'], ENV['FIXTURE_PATH'] + '/' + Rails.env] if ENV['FIXTURE_PATH']
 
     SeedDo.seed(fixture_paths, filter)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: seed-do
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Shinichi Maeshima
@@ -66,6 +66,7 @@ files:
 - lib/seed-do.rb
 - lib/seed-do/active_record_extension.rb
 - lib/seed-do/block_hash.rb
+- lib/seed-do/bulk_seeder.rb
 - lib/seed-do/capistrano.rb
 - lib/seed-do/capistrano3.rb
 - lib/seed-do/railtie.rb
@@ -78,7 +79,8 @@ files:
 homepage: http://github.com/willnet/seed-do
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -93,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Easily manage seed data in your Active Record application
 test_files: []